Roman2K-rails-test-serving 0.1.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008 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/README.rdoc

@@ -0,0 +1,28 @@
+Tired of waiting 10 seconds before your tests run? RailsTestServing can make them run almost instantly. Details in the {introduction article}[http://roman.flucti.com/a-test-server-for-rails-applications].
+
+== Quick usage instructions
+
+1.  Insert the following lines at the very top of <tt>test/test_helper.rb</tt>:
+      require 'rails_test_serving'
+      RailsTestServing.boot
+
+2.  Start the server:
+      cd <project-dir>
+      ruby test/test_helper.rb --serve
+
+3.  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).
+
+<b>Note:</b> if the server is not started, tests fall back to running the usual way.
+
+== Caveats
+
+* 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
+
+Written by {Roman Le Négrate}[http://roman.flucti.com] ({contact}[mailto:roman.lenegrate@gmail.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.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"
+  p.email           = "roman.lenegrate@gmail.com"
+  p.ignore_pattern  = "*.gemspec"
+  p.development_dependencies = []
+  p.rdoc_options    = %w(--main README.rdoc --inline-source --line-numbers --charset UTF-8)
+end

data/lib/rails_test_serving.rb

@@ -0,0 +1,352 @@
+require 'thread'
+require 'test/unit'
+require 'drb/unix'
+require 'stringio'
+require 'benchmark'
+
+module RailsTestServing
+  class InvalidArgumentPattern < ArgumentError
+  end
+  class ServerUnavailable < StandardError
+  end
+  
+  SERVICE_URI = "drbunix:tmp/sockets/test_server.sock"
+  
+  def self.boot(argv=ARGV)
+    if argv.delete('--serve')
+      Server.start
+    elsif !argv.delete('--local')
+      Client.run_tests
+    end
+  end
+  
+  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
+  
+  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(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
+  
+  class Server
+    GUARD = Mutex.new
+    
+    def self.start
+      DRb.start_service(SERVICE_URI, Server.new)
+      DRb.thread.join
+    end
+    
+    def initialize
+      ENV['RAILS_ENV'] = 'test'
+      enable_dependency_tracking
+      start_cleaner
+      load_framework
+      
+      log "** Test server started (##{$$})\n"
+    end
+    
+    def run(file, argv)
+      GUARD.synchronize { perform_run(file, argv) }
+    end
+    
+  private
+  
+    def log(message)
+      $stdout.print(message)
+      $stdout.flush
+    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 enable_dependency_tracking
+      require 'initializer'
+      
+      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 { require 'test_helper' }
+    end
+    
+    def perform_run(file, argv)
+      sanitize_arguments! file, argv
+      
+      log ">> " + [shorten_path(file), *argv].join(' ')
+      
+      result = nil
+      elapsed = Benchmark.realtime do
+        result = capture_test_result(file, argv)
+      end
+      log " (%d ms)\n" % (elapsed * 1000)
+      result
+    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
+    
+    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
+    
+  private
+  
+    def find_index_by_pattern(enumerable, pattern)
+      enumerable.each_with_index do |element, index|
+        return index if pattern === element
+      end
+      nil
+    end
+  end
+  
+  class Cleaner
+    include ConstantManagement
+    
+    BREATH = 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 BREATH while @working
+      begin
+        reload_app
+        yield
+      ensure
+        @working = true
+        sleep BREATH 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.cleanup_application
+    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.reload_application
+    end
+  end
+end unless defined? RailsTestServing

data/rails-test-serving.gemspec

@@ -0,0 +1,68 @@
+
+# Gem::Specification for Rails-test-serving-0.1.0
+# Originally generated by Echoe
+
+--- !ruby/object:Gem::Specification 
+name: rails-test-serving
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- "Roman Le N\xC3\xA9grate"
+autorequire: 
+bindir: bin
+
+date: 2008-11-16 00:00:00 +01: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.rb
+- LICENSE
+- README.rdoc
+files: 
+- lib/rails_test_serving.rb
+- LICENSE
+- Manifest
+- rails-test-serving.gemspec
+- Rakefile
+- README.rdoc
+- test/rails_test_serving_test.rb
+has_rdoc: true
+homepage: https://github.com/Roman2K/rails-test-serving
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+- --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.1
+specification_version: 2
+summary: Makes unit tests of a Rails application run instantly
+test_files: 
+- test/rails_test_serving_test.rb

data/test/rails_test_serving_test.rb

@@ -0,0 +1,211 @@
+require 'test/unit'
+require 'mocha'
+Mocha::Configuration.prevent :stubbing_non_existent_method
+Mocha::Configuration.warn_when :stubbing_method_unnecessarily
+
+require 'rails_test_serving'
+
+class RailsTestServingTest < Test::Unit::TestCase
+  include RailsTestServing
+  
+# class
+
+  def test_boot
+    argv = []
+    Client.expects(:run_tests)
+    RailsTestServing.boot(argv)
+    
+    argv = ['--local']
+    Client.expects(:run_tests).never
+    RailsTestServing.boot(argv)
+    assert_equal [], argv
+    
+    argv = ["--serve"]
+    Server.expects(:start)
+    RailsTestServing.boot(argv)
+    assert_equal [], argv
+  end
+end
+
+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 [C, B],  subclasses_of(A)
+    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
+
+class RailsTestServing::ClientTest < Test::Unit::TestCase
+  C = RailsTestServing::Client
+  
+  def test_run_tests
+    C.expects(:run_tests!)
+    C.run_tests
+    
+    C.disable do
+      C.expects(:run_tests!).never
+      C.run_tests
+    end
+  end
+end
+
+class RailsTestServing::ServerTest < Test::Unit::TestCase
+  
+# private
+
+  def test_perform_run
+    server = stub_server
+    file, argv = "test.rb", ["-n", "/pat/"]
+    
+    server.stubs(:sanitize_arguments!)
+    Benchmark.stubs(:realtime).yields.returns 1
+    
+    server.expects(:log).with(">> test.rb -n /pat/").once
+    server.stubs(:capture_test_result).with(file, argv).returns "result"
+    server.expects(:log).with(" (1000 ms)\n").once
+  
+    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_shorten_path
+    server = stub_server
+    Dir.stubs(:pwd).returns '/base'
+    
+    assert_equal 'test.rb', server.instance_eval { shorten_path 'test.rb' }
+    assert_equal 'test.rb', server.instance_eval { shorten_path '/base/test.rb' }
+    assert_equal '/other-base/test.rb', server.instance_eval { shorten_path '/other-base/test.rb' }
+    assert_equal '/other-base/test.rb', server.instance_eval { shorten_path '/other-base/././test.rb' }
+  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
+  
+  def test_capture_standard_stream
+    server = stub_server
+    assert_equal STDOUT, $stdout  # sanity check
+    
+    captured = server.instance_eval { capture_standard_stream('out') { print "test" } }
+    
+    assert_equal "test", captured
+    assert_equal STDOUT, $stdout
+  end
+  
+  def test_capture_testrunner_result
+    server = stub_server
+    
+    captured = server.instance_eval do
+      capture_testrunner_result { Thread.current["test_runner_io"].print "test" }
+    end
+    
+    assert_equal "test", captured
+  end
+  
+private
+
+  S = RailsTestServing::Server
+  
+  def stub_server
+    S.any_instance.stubs(:enable_dependency_tracking)
+    S.any_instance.stubs(:start_cleaner)
+    S.any_instance.stubs(:load_framework)
+    S.any_instance.stubs(:log)
+    S.new
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: Roman2K-rails-test-serving
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- "Roman Le N\xC3\xA9grate"
+autorequire: 
+bindir: bin
+cert_chain: 
+date: 2008-11-15 15:00:00 -08: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.rb
+- LICENSE
+- README.rdoc
+files: 
+- lib/rails_test_serving.rb
+- LICENSE
+- Manifest
+- rails-test-serving.gemspec
+- Rakefile
+- README.rdoc
+- test/rails_test_serving_test.rb
+has_rdoc: true
+homepage: https://github.com/Roman2K/rails-test-serving
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+- --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.2.0
+signing_key: 
+specification_version: 2
+summary: Makes unit tests of a Rails application run instantly
+test_files: 
+- test/rails_test_serving_test.rb