pietervisser-spork 0.7.5

data/lib/spork/test_framework.rb

@@ -0,0 +1,167 @@
+class Spork::TestFramework
+  LOAD_PREFERENCE = ['RSpec', 'Cucumber']
+  BOOTSTRAP_FILE = File.dirname(__FILE__) + "/../../assets/bootstrap.rb"
+
+  @@supported_test_frameworks = []
+  attr_reader :stdout, :stderr
+
+  class FactoryException < Exception; end
+
+  class NoFrameworksAvailable < FactoryException
+    def message
+      "I can't find any testing frameworks to use.  Are you running me from a project directory?"
+    end
+  end
+
+  class FrameworkNotAvailable < FactoryException
+    def initialize(framework)
+      @framework = framework
+    end
+
+    def message
+      "I can't find the file #{@framework.helper_file} for the #{@framework.short_name} testing framework.\nAre you running me from the project directory?"
+    end
+  end
+
+  class NoFrameworkMatched < FactoryException
+    def initialize(beginning_with)
+      @beginning_with = beginning_with
+    end
+
+    def message
+      "Couldn't find a supported test framework that begins with '#{@beginning_with}'"
+    end
+  end
+
+  def initialize(stdout = STDOUT, stderr = STDERR)
+    @stdout, @stderr = stdout, stderr
+  end
+
+  def self.factory(output = STDOUT, error = STDERR, beginning_with = nil)
+    if beginning_with
+      @klass = supported_test_frameworks(beginning_with).first
+      raise(NoFrameworkMatched.new(beginning_with)) if @klass.nil?
+      raise(FrameworkNotAvailable.new(@klass)) unless @klass.available?
+    else
+      @klass = available_test_frameworks.first
+      raise(NoFrameworksAvailable.new) unless @klass
+    end
+    @klass.new(output, error)
+  end
+
+  def self.helper_file
+    self::HELPER_FILE
+  end
+
+  def self.default_port
+    (ENV["#{short_name.upcase}_DRB"] || self::DEFAULT_PORT).to_i
+  end
+
+  def self.short_name
+    self.name.gsub('Spork::TestFramework::', '')
+  end
+
+  # Returns a list of all testing servers that have detected their testing framework being used in the project.
+  def self.available_test_frameworks
+    supported_test_frameworks.select { |s| s.available? }
+  end
+
+  # Returns a list of all servers that have been implemented (it keeps track of them automatically via Class.inherited)
+  def self.supported_test_frameworks(starting_with = nil)
+    @@supported_test_frameworks.sort! { |a,b| a.load_preference_index <=> b.load_preference_index }
+    return @@supported_test_frameworks if starting_with.nil?
+    @@supported_test_frameworks.select do |s|
+      s.short_name.match(/^#{Regexp.escape(starting_with)}/i)
+    end
+  end
+
+  def short_name
+    self.class.short_name
+  end
+
+  def helper_file
+    self.class.helper_file
+  end
+
+  # Detects if the test helper has been bootstrapped.
+  def bootstrapped?
+    File.read(helper_file).include?("Spork.prefork")
+  end
+
+  # Bootstraps the current test helper file by prepending a Spork.prefork and Spork.each_run block at the beginning.
+  def bootstrap
+    if bootstrapped?
+      stderr.puts "Already bootstrapped!"
+      return
+    end
+    stderr.puts "Bootstrapping #{helper_file}."
+    contents = File.read(helper_file)
+    bootstrap_code = File.read(BOOTSTRAP_FILE)
+    File.open(helper_file, "wb") do |f|
+      f.puts bootstrap_code
+      f.puts contents
+    end
+
+    stderr.puts "Done. Edit #{helper_file} now with your favorite text editor and follow the instructions."
+    true
+  end
+
+  # Returns true if the testing frameworks helper file exists.  Override if this is not sufficient to detect your testing framework.
+  def self.available?
+    File.exist?(helper_file)
+  end
+
+  # Used to specify
+  def self.load_preference_index
+    LOAD_PREFERENCE.index(short_name) || LOAD_PREFERENCE.length
+  end
+
+  def preload
+    Spork.exec_prefork do
+      unless bootstrapped?
+        stderr.puts "#{helper_file} has not been bootstrapped.  Run spork --bootstrap to do so."
+        stderr.flush
+
+        if framework.bootstrap_required?
+          stderr.puts "I can't do anything for you by default for the framework your using: #{framework.short_name}.\nYou must bootstrap #{helper_file} to continue."
+          stderr.flush
+          return false
+        else
+          load(framework.entry_point)
+        end
+      end
+
+      framework.preload do
+        if bootstrapped?
+          stderr.puts "Loading Spork.prefork block..."
+          stderr.flush
+          load(helper_file)
+        end
+      end
+    end
+    true
+  end
+
+  def run_tests(argv, stderr, stdout)
+    raise NotImplementedError
+  end
+
+  def entry_point
+    bootstrapped? ? helper_file : framework.entry_point
+  end
+
+  def default_port
+    self.class.default_port
+  end
+
+  protected
+    def self.inherited(subclass)
+      @@supported_test_frameworks << subclass
+    end
+
+    def framework
+      @framework ||= Spork::AppFramework.detect_framework
+    end
+end
+
+Spork.detect_and_require('spork/test_framework/*.rb')

data/lib/spork.rb

@@ -0,0 +1,130 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+require 'pathname'
+module Spork
+  BINARY = File.expand_path(File.dirname(__FILE__) + '/../bin/spork')
+  LIBDIR = Pathname.new(File.expand_path(File.dirname(__FILE__)))
+
+  autoload :Server,        (LIBDIR + 'spork/server').to_s
+  autoload :TestFramework, (LIBDIR + 'spork/test_framework').to_s
+  autoload :AppFramework,  (LIBDIR + 'spork/app_framework').to_s
+  autoload :RunStrategy,   (LIBDIR + 'spork/run_strategy').to_s
+  autoload :Runner,        (LIBDIR + 'spork/runner').to_s
+  autoload :Forker,        (LIBDIR + 'spork/forker').to_s
+  autoload :Diagnoser,     (LIBDIR + 'spork/diagnoser').to_s
+
+  class << self
+    # Run a block, during prefork mode.  By default, if prefork is called twice in the same file and line number, the supplied block will only be ran once.
+    #
+    # == Parameters
+    #
+    # * +prevent_double_run+ - Pass false to disable double run prevention
+    def prefork(prevent_double_run = true, &block)
+      return if prevent_double_run && already_ran?(caller.first)
+      yield
+    end
+    
+    # Run a block AFTER the fork occurs.  By default, if prefork is called twice in the same file and line number, the supplied block will only be ran once.
+    #
+    # == Parameters
+    #
+    # * +prevent_double_run+ - Pass false to disable double run prevention
+    def each_run(prevent_double_run = true, &block)
+      return if prevent_double_run && already_ran?(caller.first)
+      if @state == :using_spork
+        each_run_procs << block
+      else
+        yield
+      end
+    end
+    
+    # Used by the server. Sets the state to activate spork. Otherwise, prefork and each_run are run in passive mode, allowing specs without a Spork server.
+    def using_spork!
+      @state = :using_spork
+    end
+    
+    def using_spork?
+      @state == :using_spork
+    end
+
+    # Used by the server.  Returns the current state of Spork.
+    def state
+      @state ||= :not_using_spork
+    end
+    
+    # Used by the server.  Called when loading the prefork blocks of the code.
+    def exec_prefork(&block)
+      using_spork!
+      yield
+    end
+    
+    # Used by the server.  Called to run all of the prefork blocks.
+    def exec_each_run(&block)
+      each_run_procs.each { |p| p.call }
+      each_run_procs.clear
+      yield if block_given?
+    end
+    
+    # Traps an instance method of a class (or module) so any calls to it don't actually run until Spork.exec_each_run
+    def trap_method(klass, method_name)
+      method_name_without_spork, method_name_with_spork = alias_method_names(method_name, :spork)
+      
+      klass.class_eval <<-EOF, __FILE__, __LINE__ + 1
+        alias :#{method_name_without_spork} :#{method_name} unless method_defined?(:#{method_name_without_spork}) 
+        def #{method_name}(*args)
+          Spork.each_run(false) do
+            #{method_name_without_spork}(*args)
+          end
+        end
+      EOF
+    end
+    
+    # Same as trap_method, but for class methods instead
+    def trap_class_method(klass, method_name)
+      trap_method((class << klass; self; end), method_name)
+    end
+    
+    def detect_and_require(subfolder)
+      ([LIBDIR.to_s] + other_spork_gem_load_paths).uniq.each do |gem_path|
+        Dir.glob(File.join(gem_path, subfolder)).each { |file| require file }
+      end
+    end
+
+    def other_spork_gem_load_paths
+      @other_spork_gem_load_paths ||= (
+        Gem.latest_load_paths.grep(/spork/).select do |g|
+          not g.match(%r{/spork-[0-9\-.]+/lib}) # don't include other versions of spork
+        end
+      )
+    end
+
+    private
+      def alias_method_names(method_name, feature)
+        /^(.+?)([\?\!]{0,1})$/.match(method_name.to_s)
+        ["#{$1}_without_spork#{$2}", "#{$1}_with_spork#{$2}"]
+      end
+      
+      def already_ran
+        @already_ran ||= []
+      end
+
+      def expanded_caller(caller_line)
+        path, file = File.split caller_line
+        if caller_line.end_with? file
+          file, line = file.split(":")
+        else
+          line = caller_line.match(/(\d+)$/)[1]
+        end
+        File.expand_path(File.join(path, file), Dir.pwd) + ":" + line
+      end
+      
+      def already_ran?(caller_script_and_line)
+        return true if already_ran.include?(expanded_caller(caller_script_and_line))
+        already_ran << expanded_caller(caller_script_and_line)
+        false
+      end
+      
+      def each_run_procs
+        @each_run_procs ||= []
+      end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,108 @@
+require 'rubygems'
+
+unless $spec_helper_loaded
+  $spec_helper_loaded = true
+
+  $LOAD_PATH.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
+  SPEC_TMP_DIR = File.expand_path('tmp', File.dirname(__FILE__))
+  require 'spork'
+  require 'stringio'
+  require 'fileutils'
+
+  Spec::Runner.configure do |config|
+    config.before(:each) do
+      $test_stdout = StringIO.new
+      $test_stderr = StringIO.new
+      @current_dir = nil
+    end
+  
+    config.after(:each) do
+      FileUtils.rm_rf(SPEC_TMP_DIR) if File.directory?(SPEC_TMP_DIR)
+    
+    end
+  
+    def create_file(filename, contents)
+      FileUtils.mkdir_p(SPEC_TMP_DIR) unless File.directory?(SPEC_TMP_DIR)
+    
+      in_current_dir do
+        FileUtils.mkdir_p(File.dirname(filename))
+        File.open(filename, 'wb') { |f| f << contents }
+      end
+    end
+
+    def create_helper_file(test_framework = FakeFramework)
+      create_file(test_framework.helper_file, "# stub spec helper file")
+    end
+
+    def in_current_dir(&block)
+      Dir.chdir(current_dir, &block)
+    end
+  
+    def current_dir
+      @current_dir ||= SPEC_TMP_DIR
+    end
+    
+    def change_current_dir(sub_path)
+      @current_dir = File.expand_path(sub_path, SPEC_TMP_DIR)
+    end
+  end
+
+
+  module Spec
+    module Matchers
+      class IncludeAStringLike
+        def initialize(substring_or_regex)
+          case substring_or_regex
+          when String
+            @regex = Regexp.new(Regexp.escape(substring_or_regex))
+          when Regexp
+            @regex = substring_or_regex
+          else
+            raise ArgumentError, "don't know what to do with the #{substring_or_regex.class} you provided"
+          end
+        end
+
+        def matches?(list_of_strings)
+          @list_of_strings = list_of_strings
+          @list_of_strings.any? { |s| s =~ @regex }
+        end
+        def failure_message
+          "#{@list_of_strings.inspect} expected to include a string like #{@regex.inspect}"
+        end
+        def negative_failure_message
+          "#{@list_of_strings.inspect} expected to not include a string like #{@regex.inspect}, but did"
+        end
+      end
+
+      def include_a_string_like(substring_or_regex)
+        IncludeAStringLike.new(substring_or_regex)
+      end
+    end
+  end
+
+  module Spork::TestIOStreams
+    def self.included(klass)
+      klass.send(:extend, ::Spork::TestIOStreams::ClassMethods)
+    end
+  
+    def stderr
+      self.class.stderr
+    end
+
+    def stdout
+      self.class.stdout
+    end
+  
+    module ClassMethods
+      def stderr
+        $test_stderr
+      end
+  
+      def stdout
+        $test_stdout
+      end
+    end
+  end
+
+  Dir.glob(File.dirname(__FILE__) + "/support/*.rb").each { |f| require(f) }
+end

data/spec/spork/app_framework/rails_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Spork::AppFramework::Rails do
+  describe ".version" do
+    it "detects the current version of rails" do
+      create_file("config/environment.rb", "RAILS_GEM_VERSION = '2.1.0'")
+      in_current_dir do
+        Spork::AppFramework::Rails.new.version.should == "2.1.0"
+      end
+      
+      create_file("config/environment.rb", 'RAILS_GEM_VERSION = "2.1.0"')
+      in_current_dir do
+        Spork::AppFramework::Rails.new.version.should == "2.1.0"
+      end
+      
+      create_file("config/environment.rb", 'RAILS_GEM_VERSION = "> 2.1.0"')
+      in_current_dir do
+        Spork::AppFramework::Rails.new.version.should == "> 2.1.0"
+      end
+    end
+  end
+end

data/spec/spork/app_framework/unknown_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Spork::AppFramework::Unknown do
+  it "requires bootstrapping" do
+    Spork::AppFramework::Unknown.new.bootstrap_required?.should == true
+  end
+  
+  it "has no known entry point" do
+    Spork::AppFramework::Unknown.new.entry_point.should be_nil
+  end
+end
+

data/spec/spork/app_framework_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Spork::AppFramework do
+  describe ".detect_framework" do
+    it "detects when rails is installed and available" do
+      create_file("config/environment.rb", "RAILS_GEM_VERSION = '2.1.0'")
+      in_current_dir do
+        Spork::AppFramework.detect_framework.short_name.should == "Rails"
+      end
+    end
+  
+    it "returns Unknown when no framework known detected" do
+      Spork::AppFramework.detect_framework.short_name.should == "Unknown"
+    end
+  end
+end

data/spec/spork/diagnoser_spec.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+
+describe Spork::Diagnoser do
+  after(:each) do
+    Spork::Diagnoser.remove_hook!
+    Spork::Diagnoser.loaded_files.clear
+  end
+  
+  def run_simulation(directory, filename = nil, contents = nil, &block)
+    FileUtils.mkdir_p(directory)
+    Dir.chdir(directory) do
+      if filename
+        File.open(filename, 'wb') { |f| f << contents }
+        Spork::Diagnoser.install_hook!
+        require filename
+      end
+      yield if block_given?
+    end
+  end
+  
+  it "installs it's hook and tells you when files have been loaded" do
+    run_simulation(SPEC_TMP_DIR, 'my_awesome_library_include.rb', '1 + 5')
+    Spork::Diagnoser.loaded_files.keys.should include_a_string_like('my_awesome_library_include')
+  end
+
+  it 'excludes files outside of Dir.pwd' do
+    run_simulation(SPEC_TMP_DIR + '/project_root', '../external_dependency.rb', '1 + 5')
+    Spork::Diagnoser.loaded_files.keys.should_not include_a_string_like('external_dependency')
+  end
+  
+  it "excludes files outside of Dir.pwd but in ruby's include path" do
+    directory = SPEC_TMP_DIR + '/project_root'
+    external_dependency_dir = SPEC_TMP_DIR + '/external_dependency'
+    $: << external_dependency_dir
+    FileUtils.mkdir_p(directory)
+    FileUtils.mkdir_p(external_dependency_dir)
+    Dir.chdir(directory) do
+      File.open(external_dependency_dir + '/the_most_awesome_external_dependency_ever.rb', 'wb') { |f| f << 'funtimes = true' }
+      Spork::Diagnoser.install_hook!
+      require 'the_most_awesome_external_dependency_ever'
+    end
+    
+    Spork::Diagnoser.loaded_files.keys.should_not include_a_string_like('the_most_awesome_external_dependency_ever')
+    $:.pop
+  end
+  
+  it "expands files to their fully their fully qualified path" do
+    directory = SPEC_TMP_DIR + '/project_root'
+    lib_directory = directory + '/lib'
+    $: << lib_directory
+    FileUtils.mkdir_p(lib_directory)
+    Dir.chdir(directory) do
+      File.open(lib_directory + "/the_most_awesome_lib_file_ever.rb", "wb") { |f| f << "funtimes = true" }
+      Spork::Diagnoser.install_hook!
+      require 'the_most_awesome_lib_file_ever'
+    end
+    
+    Spork::Diagnoser.loaded_files.keys.should include_a_string_like('lib/the_most_awesome_lib_file_ever')
+    $:.pop
+  end
+  
+  it "can tell the difference between a folder in the project path and a file in an external path" do
+    directory = SPEC_TMP_DIR + '/project_root'
+    external_dependency_dir = SPEC_TMP_DIR + '/external_dependency'
+    $: << external_dependency_dir
+    FileUtils.mkdir_p(directory)
+    FileUtils.mkdir_p(external_dependency_dir)
+    Dir.chdir(directory) do
+      FileUtils.mkdir_p(directory + '/a_popular_folder_name')
+      File.open(external_dependency_dir + '/a_popular_folder_name.rb', 'wb') { |f| f << 'funtimes = true' }
+      Spork::Diagnoser.install_hook!
+      require 'a_popular_folder_name'
+    end
+    
+    Spork::Diagnoser.loaded_files.keys.should_not include_a_string_like('a_popular_folder_name')
+    $:.pop
+  end
+  
+  it "filters backtrace beyond the last line matching the entry point" do
+    Spork::Diagnoser.install_hook!("test_filter/environment.rb")
+    create_file("test_filter/environment.rb", "require 'test_filter/app.rb'")
+    create_file("test_filter/app.rb", "require 'test_filter/my_model.rb'")
+    create_file("test_filter/my_model.rb", "'my model here'")
+    in_current_dir do
+      require 'test_filter/environment.rb'
+    end
+    f = Spork::Diagnoser.loaded_files
+    f[f.keys.grep(/app.rb/).first].last.should include('test_filter/environment.rb')
+    f[f.keys.grep(/my_model.rb/).first].last.should include('test_filter/environment.rb')
+    f[f.keys.grep(/environment.rb/).first].should == []
+  end
+  
+  describe ".output_results" do
+    it "outputs the results relative to the current directory" do
+      Spork::Diagnoser.loaded_files["/project_path/lib/file.rb"] = "/project_path/lib/parent_file.rb:35"
+      Dir.stub!(:pwd).and_return("/project_path")
+      out = StringIO.new
+      Spork::Diagnoser.output_results(out)
+      out.string.should =~ %r([^/]lib/file.rb)
+      out.string.should =~ %r([^/]lib/parent_file.rb)
+      out.string.should_not include("/project_path/")
+    end
+  end
+end

data/spec/spork/forker_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Spork::Forker do
+  describe ".new" do
+    it "runs a block in a fork" do
+      $var = "hello world"
+      Spork::Forker.new { $var = "booyah" }.result
+      $var.should == "hello world"
+    end
+  end
+  
+  describe "#result" do
+    it "returns the result" do
+      Spork::Forker.new { "results" }.result.should == "results"
+    end
+  end
+  
+  describe "#running?" do
+    it "reports when the fork is running" do
+      forker = Spork::Forker.new { sleep 0.1 }
+      forker.running?.should == true
+      forker.result
+      sleep 0.1
+      forker.running?.should == false
+    end
+  end
+  
+  describe "#abort" do
+    it "aborts a fork and returns nil for the result" do
+      started_at = Time.now
+      ended_at = nil
+      forker = Spork::Forker.new { sleep 5 }
+      Thread.new do
+        forker.result.should == nil
+        ended_at = Time.now
+      end
+      sleep 0.5
+      forker.abort
+      sleep 0.1
+      (ended_at - started_at).should be_close(0.5, 0.1)
+      forker.running?.should == false
+    end
+  end
+end

data/spec/spork/run_strategy/forking_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Spork::RunStrategy::Forking do
+  before(:each) do
+    @fake_framework = FakeFramework.new
+    @run_strategy = Spork::RunStrategy::Forking.new(@fake_framework)
+
+  end
+
+  it "returns the result of the run_tests method from the forked child" do
+    create_helper_file
+    @fake_framework.stub!(:run_tests).and_return("tests were ran")
+    @run_strategy.run("test", STDOUT, STDIN).should == "tests were ran"
+  end
+
+  it "aborts the current running thread when another run is started" do
+    create_helper_file
+    @fake_framework.wait_time = 0.25
+    first_run = Thread.new { @run_strategy.run("test", STDOUT, STDIN).should == nil }
+    sleep(0.05)
+    @run_strategy.run("test", STDOUT, STDIN).should == true
+
+    # wait for the first to finish
+    first_run.join
+  end
+
+  it "can abort the current run" do
+    create_helper_file
+    @fake_framework.wait_time = 5
+    started_at = Time.now
+    first_run = Thread.new { @run_strategy.run("test", STDOUT, STDIN).should == true }
+    sleep(0.05)
+    @run_strategy.send(:abort)
+    sleep(0.01) while @run_strategy.running?
+
+    (Time.now - started_at).should < @fake_framework.wait_time
+  end
+end

data/spec/spork/runner_spec.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Spork::Runner do
+  def use_test_server(klass = Spork::TestFramework::RSpec)
+    @test_framework = klass.new
+    Spork::TestFramework.stub!(:factory).and_return(@test_framework)
+  end
+
+  before(:each) do
+    @out, @err = StringIO.new, StringIO.new
+  end
+  
+  it "finds a matching server with a prefix" do
+    Spork::Runner.new(["rs"], @out, @err).find_test_framework.class.should == Spork::TestFramework::RSpec
+  end
+  
+  it "shows an error message if no matching server was found" do
+    Spork::Runner.new(["argle_bargle"], @out, @err).run.should == false
+    @err.string.should include(%(Couldn't find a supported test framework that begins with 'argle_bargle'))
+  end
+  
+  it "bootstraps a server when -b is passed in" do
+    use_test_server
+    @test_framework.should_receive(:bootstrap)
+    Spork::Runner.new(['rspec', '-b'], @out, @err).run
+  end
+  
+  it "aborts if it can't preload" do
+    use_test_server
+    @test_framework.should_receive(:preload).and_return(false)
+    Spork::Server.should_not_receive(:run)
+    Spork::Runner.new(['rspec'], @out, @err).run
+  end
+  
+  it "runs the server if all is well" do
+    use_test_server
+    @test_framework.should_receive(:preload).and_return(true)
+    Spork::Server.should_receive(:run)
+    Spork::Runner.new(['rspec'], @out, @err).run
+    @err.string.should include("Using RSpec")
+  end
+  
+  it "outputs a list of supported servers, along with supported asterisk" do
+    Spork::Server.stub!(:supported_test_frameworks).and_return([Spork::TestFramework::RSpec, Spork::TestFramework::Cucumber])
+    Spork::TestFramework::RSpec.stub!(:available?).and_return(true)
+    Spork::TestFramework::Cucumber.stub!(:available?).and_return(false)
+    
+    Spork::Runner.new(['rspec'], @out, @err).supported_test_frameworks_text.should include("(*) RSpec")
+  end
+end