Roman2K-rails-test-serving 0.1.3 → 0.1.4

data/LICENSE

@@ -1,19 +1,7 @@
-Copyright (c) 2008 Roman Le Négrate
+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:
+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 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.
+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

@@ -1,6 +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
-Rakefile
-README.rdoc
-test/rails_test_serving_test.rb
 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/Rakefile

@@ -1,11 +1,11 @@
 require 'echoe'
 
-Echoe.new('rails-test-serving', '0.1.3') do |p|
+Echoe.new('rails-test-serving', '0.1.4') 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)
+  p.rdoc_options    = %w(--main README.mdown --inline-source --line-numbers --charset UTF-8)
 end

data/lib/rails_test_serving.rb

@@ -10,404 +10,13 @@ module RailsTestServing
   end
   class ServerUnavailable < StandardError
   end
-  
-  SOCKET_PATH = ['tmp', 'sockets', 'test_server.sock']
-  
-  def self.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 self.boot(argv=ARGV)
-    if argv.delete('--serve')
-      Server.start
-    elsif !argv.delete('--local')
-      Client.run_tests
-    end
-  end
-  
-  def self.options
-    @options ||= begin
-      options = $test_server_options || {}
-      options[:reload] ||= []
-      options
-    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(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
-  
-  class Server
-    GUARD = Mutex.new
-    
-    def self.start
-      DRb.start_service(RailsTestServing.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
-    
-    # TODO clean this up, making 'path' a Pathname instead of a String
-    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 '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 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(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 unless defined? RailsTestServing
+
+  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/rails-test-serving.gemspec

@@ -2,23 +2,23 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rails-test-serving}
-  s.version = "0.1.3"
+  s.version = "0.1.4"
 
   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{2008-11-21}
+  s.date = %q{2009-02-08}
   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"]
+  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.has_rdoc = true
   s.homepage = %q{https://github.com/Roman2K/rails-test-serving}
-  s.rdoc_options = ["--main", "README.rdoc", "--inline-source", "--line-numbers", "--charset", "UTF-8"]
+  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.1}
   s.summary = %q{Makes unit tests of a Rails application run instantly}
-  s.test_files = ["test/rails_test_serving_test.rb"]
+  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

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

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: Roman2K-rails-test-serving
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors: 
 - "Roman Le N\xC3\xA9grate"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-21 00:00:00 -08:00
+date: 2009-02-08 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -31,12 +31,19 @@ files:
 - 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
 has_rdoc: true
 homepage: https://github.com/Roman2K/rails-test-serving
 post_install_message: 
 rdoc_options: 
 - --main
-- README.rdoc
+- README.mdown
 - --inline-source
 - --line-numbers
 - --charset
@@ -63,4 +70,10 @@ signing_key:
 specification_version: 2
 summary: Makes unit tests of a Rails application run instantly
 test_files: 
-- test/rails_test_serving_test.rb
+- 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.rdoc

@@ -1,63 +0,0 @@
-Tired of waiting 10 seconds before your tests run? RailsTestServing can make them run almost instantly.
-
-== Usage
-
-1.  Install the gem:
-      gem install Roman2K-rails-test-serving -v '>= 0.1.3' -s http://gems.github.com
-
-2.  Insert the following lines at the very top of <tt>test/test_helper.rb</tt>:
-      require 'rubygems'
-      require 'rails_test_serving'
-      RailsTestServing.boot
-
-3.  Append the following line to <tt>~/.bash_profile</tt>:
-      export RUBYLIB=".:test:$RUBYLIB"
-    
-    If you get loading errors during the next steps:
-    * Move the +RUBYLIB+ line from <tt>~/.bash_profile</tt> to <tt>~/.bash_login</tt> 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.  Details in the {introduction article}[http://roman.flucti.com/a-test-server-for-rails-applications].
-
-<b>Note:</b> 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 <tt>$test_server_options</tt> right before <tt>require 'rails_test_serving'</tt>. It must be a hash with symbol keys. Currently available options are:
-+reload+::  An array of regular expressions (or any object responding to <tt>#===</tt>) 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 not removed before the new +require+.
-
-Example <tt>test_helper.rb</tt> head:
-  require 'rubygems'
-
-  $test_server_options = { :reload => [/blueprint/] }
-  require 'rails_test_serving'
-  RailsTestServing.boot
-  
-  # ...remainder here...
-
-== Caveats
-
-* Tested working with Rails 2.1.2 up to 2.2.0 RC2. Compatibility with versions of Rails out of that range is 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/test/rails_test_serving_test.rb

@@ -1,294 +0,0 @@
-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'
-
-class RailsTestServingTest < Test::Unit::TestCase
-  include RailsTestServing
-  
-# class
-
-  def test_service_uri
-    # 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", RailsTestServing.service_uri
-    end
-    
-    # RAILS_ROOT is in 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", RailsTestServing.service_uri
-    end
-    
-    # RAILS_ROOT cannot be determined
-    setup_service_uri_test do
-      Pathname.stubs(:pwd).returns(Pathname("/foo/bar"))
-      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) { RailsTestServing.service_uri }
-    end
-  end
-
-  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
-  
-private
-
-  def setup_service_uri_test(wont_mkpath=false)
-    old_load_path = $:.dup
-    begin
-      return yield
-    ensure
-      RailsTestServing.instance_variable_set(:@service_uri, nil)
-      $:.replace(old_load_path)
-    end
-  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
-
-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