specjour 0.7.0 → 2.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2b2e786f14b5e926503fdadd4a4504fc188ded2c
+  data.tar.gz: e2de43dfdccc720d0befdad67fd51ffc239cc63a
+SHA512:
+  metadata.gz: 0228128342542bf82575bcbd36a1a00e42852dec83735dbdb1b46186647eec849b11cb7fae53294b6087250af505ac28a60b7406f38926133e4eb1b6ffe8f195
+  data.tar.gz: 1db0922eac8c9552bade26f9669bc9149393e780741ffb4d359d70a598d83c322ba250ad2fb61de783926a24c628436ff76e6f241d39e6f18561f2d59027b2bc

data/History.markdown

@@ -1,6 +1,18 @@
 History
 =======
 
+0.7.1 / (master)
+---------------------------
+* [fixed] printer exit\_status returns false if there are no reporters
+* [fixed] regression when running a subdirectory. Specjour was loading all
+  specs, even those outside of the default spec directory, i.e. a fast\_specs/
+  directory.
+* [fixed] "file has vanished" bug. The specjour listener can now transition
+  between networks without restarts.
+* [fixed] before(:all). Specjour now distributes before(:all) as a group.
+  Previously, each example would be distributed alone, effectively turning
+  before(:all) into before(:each).
+
 0.7.0 / 2012-11-21
 ---------------------------
 * [added] Cucumber now distributes individual scenarios instead of files

data/README.markdown

@@ -1,6 +1,23 @@
 # Specjour
 
-## FUCK SETI. Run specs with your spare CPU cycles.
+## Notes
+  Listener daemonized or foregrounded
+    forks a loader
+      loader should load, setsid, then exit
+        all workers then have the same sid and gid with no parent pid
+        worker pgid = 100 sid = 100
+          webkit_server
+        worker pgid = 100 sid = 100
+          webkit_server
+
+  performance.txt
+  printing informational messages
+  single specjour command starts daemon
+  interrupts
+  handle no careful_test database
+  bonjour announce project names
+  printer#project_name aliases
+
 
 ## Instructions
 
@@ -20,6 +37,12 @@ by [parallel\_tests](http://github.com/grosser/parallel_tests)):
       database: project_name_test<%=ENV['TEST_ENV_NUMBER']%>
 
 ## Give it a try
+
+  source .dev
+  bin/specjour listen -f -l
+  bin/specjour spec/
+
+
 Run `specjour` to start a dispatcher, manager, and multiple workers in the same
 terminal window.
 

data/Rakefile

@@ -1,21 +1,21 @@
 require 'bundler/gem_tasks'
 require "bundler/setup"
 
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec)
+# require 'rspec/core/rake_task'
+# RSpec::Core::RakeTask.new(:spec)
 
-RSpec::Core::RakeTask.new(:rcov)
+# RSpec::Core::RakeTask.new(:rcov)
 
-task :default => :spec
+# task :default => :spec
 
-begin
-  require 'yard'
-  YARD::Rake::YardocTask.new
-rescue LoadError
-  task :yardoc do
-    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
-  end
-end
+# begin
+#   require 'yard'
+#   YARD::Rake::YardocTask.new
+# rescue LoadError
+#   task :yardoc do
+#     abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+#   end
+# end
 
 desc "tag, push gem, push to github"
 task :prerelease do

data/bin/specjour

@@ -2,4 +2,6 @@
 require 'specjour'
 
 $PROGRAM_NAME = File.basename(__FILE__)
-Specjour::CLI.start
+Specjour.load_plugins
+Specjour.load_custom_hooks
+Specjour::CLI.new.start

data/lib/specjour/cli.rb

@@ -1,135 +1,111 @@
 module Specjour
-  require 'thor'
-  class CLI < Thor
+  require 'optparse'
+  class CLI
+    include Logger
 
-    def self.worker_option
-      method_option :workers, :aliases => "-w", :type => :numeric, :desc => "Number of concurent processes to run. Defaults to your system's available cores."
-    end
+    COMMANDS = %w(listen ls stop)
 
-    def self.dispatcher_option
-      method_option :alias, :aliases => "-a", :desc => "Project name advertised to listeners"
-    end
+    attr_accessor :options
 
-    def self.rsync_port_option
-      method_option :rsync_port, :type => :numeric, :default => 23456, :desc => "Port to use for rsync daemon"
+    def initialize
+      self.options = {}
     end
 
-    # allow specjour to be called with path arguments
-    def self.start(original_args=ARGV, config={})
-      Specjour.trap_interrupt
-      real_tasks = all_tasks.keys | @map.keys
-      unless real_tasks.include? original_args.first
-        original_args.unshift default_task
+    def stop_running_listener
+      listener = Listener.new
+      if listener.started?
+        listener.stop
       end
-      super(original_args)
+      listener
     end
 
-    default_task :dispatch
-
-    class_option :log, :aliases => "-l", :type => :boolean, :desc => "Print debug messages to $stderr"
-
-    desc "listen", "Listen for incoming tests to run"
-    long_desc <<-DESC
-      Advertise availability to run tests for the current directory.
-    DESC
-    worker_option
-    rsync_port_option
-    method_option :projects, :aliases => "-p", :type => :array, :desc => "Projects supported by this listener"
-    def listen
-      handle_logging
-      handle_workers
-      params[:registered_projects] = params.delete(:projects) || [File.basename(Dir.pwd)]
-      append_to_program_name "listen"
-      Specjour::Manager.new(params).start
+    def start
+      Specjour.trap_interrupt_with_exit
+      parser.parse!
+      append_to_program_name(ARGV[0])
+      ensure_alias
+      case ARGV[0]
+      when "listen"
+        listener = stop_running_listener
+        listener.daemonize unless options[:foreground]
+        listener.start
+      when "ls"
+        puts "Plugins:"
+        puts Specjour.plugin_manager.plugins
+      when "stop"
+        listener = Listener.new
+        if listener.started?
+          puts "Stopping listener with pid #{listener.pid}"
+          listener.stop
+        else
+          abort("No listener found")
+        end
+      when "help"
+        abort("Commands are: #{COMMANDS.join(" ")}")
+      else
+        test_paths = ARGV[0..-1]
+        if options[:workers]
+          stop_running_listener
+          if options[:workers] > 0
+            Listener.ensure_started
+          end
+        else
+          Listener.ensure_started
+        end
+        printer = Printer.new test_paths: Array(test_paths)
+        printer.announce
+        printer.start_rsync
+        printer.start
+      end
     end
 
-    desc "load", "load the app, then fork workers", :hide => true
-    worker_option
-    method_option :printer_uri, :required => true
-    method_option :project_path, :required => true
-    method_option :task, :required => true
-    method_option :test_paths, :type => :array, :default => []
-    method_option :quiet, :type => :boolean, :default => false
-    def load
-      handle_logging
-      handle_workers
-      append_to_program_name "load"
-      Specjour::Loader.new(params).start
+    def ensure_alias
+      if Specjour.configuration.project_aliases.empty?
+        Specjour.configuration.project_aliases = [File.basename(Dir.pwd)]
+      end
     end
 
-    desc "dispatch [test_paths]", "Send tests to a listener"
-    worker_option
-    dispatcher_option
-    rsync_port_option
-    long_desc <<-DESC
-      This is run when you simply type `specjour`.
-      By default, it will run the specs and features found in the current directory.
-      If you like, you can run a subset of tests by specifying the folder containing the tests.\n
-      Examples\n
-      `specjour dispatch spec`\n
-      `specjour dispatch features`\n
-      `specjour dispatch spec/models features/sign_up.feature`\n
-    DESC
-    def dispatch(*paths)
-      handle_logging
-      handle_workers
-      handle_dispatcher(paths)
-      append_to_program_name "dispatch"
-      Specjour::Dispatcher.new(params).start
-    end
+    def parser
+      @parser ||= OptionParser.new do |parser|
+        parser.banner = "Usage: specjour [command] [options] [files or directories]\n\nCommands are #{COMMANDS.join(",")}\n\n"
 
-    desc "prepare [PROJECT_PATH]", "Run the prepare task on all listening workers"
-    long_desc <<-DESC
-      Run the Specjour::Configuration.prepare block on all listening workers.
-      Defaults to dropping the database, then loading the schema.
-    DESC
-    worker_option
-    dispatcher_option
-    rsync_port_option
-    def prepare(path = Dir.pwd)
-      handle_logging
-      handle_workers
-      params[:project_path] = File.expand_path(path)
-      params[:project_alias] = params.delete(:alias)
-      params[:test_paths] = []
-      params[:worker_task] = 'prepare'
-      append_to_program_name "prepare"
-      Specjour::Dispatcher.new(params).start
-    end
+        parser.on('-b', '--backtrace', 'Include specjour in the backtrace (do not scrub backtrace)') do |o|
+          options[:full_backtrace] = true
+          Specjour.configuration.full_backtrace = true
+        end
 
-    map %w(-v --version) => :version
-    desc "version", "Show the current version"
-    def version
-      puts Specjour::VERSION
-    end
+        parser.on("-l", "--log", "Enable informational logging") do
+          Specjour.new_logger ::Logger::INFO
+        end
 
-    protected
+        parser.on("-d", "--debug", "Enable debug logging") do
+          Specjour.new_logger ::Logger::DEBUG
+        end
 
-    def append_to_program_name(command)
-      $PROGRAM_NAME = "#{$PROGRAM_NAME} #{command}"
-    end
+        parser.on("-f", "--foreground", "Foreground the listener") do |option|
+          options[:foreground] = option
+        end
 
-    def params
-      @params ||= options.dup
-    end
+        parser.on("-w", "--workers NUM", Numeric, "Number of workers") do |option|
+          options[:workers] = option.to_i
+          Specjour.configuration.worker_size = options[:workers]
+        end
 
-    def handle_logging
-      Specjour.new_logger(Logger::DEBUG) if options['log']
-    end
+        parser.on("-a", "--alias NAME", Array, "Project name alias") do |option|
+          Specjour.configuration.project_aliases = option
+        end
 
-    def handle_workers
-      params[:worker_size] = options["workers"] || CPU.cores
+        parser.on("-v", "--version", "Version number") do |option|
+          puts Specjour::VERSION
+          exit
+        end
+      end
     end
 
-    def handle_dispatcher(paths)
-      if paths.empty?
-        params[:project_path] = Dir.pwd
-      else
-        params[:project_path] = File.expand_path(paths.first.sub(/(spec|features).*$/, ''))
-      end
-      params[:test_paths] = paths
-      params[:project_alias] = params.delete(:alias)
-      raise ArgumentError, "Cannot dispatch line numbers" if paths.any? {|p| p =~ /:\d+/}
+    private
+
+    def append_to_program_name(command)
+      $PROGRAM_NAME = "#{$PROGRAM_NAME} #{command}"
     end
   end
 end

data/lib/specjour/colors.rb

@@ -0,0 +1,23 @@
+module Specjour
+  module Colors
+
+    VT100_COLORS = {
+      :black => 30,
+      :red => 31,
+      :green => 32,
+      :yellow => 33,
+      :blue => 34,
+      :magenta => 35,
+      :cyan => 36,
+      :white => 37
+    }
+
+    def colorize(text, color)
+      if output.tty?
+        "\e[#{VT100_COLORS[color]}m#{text}\e[0m"
+      else
+        text
+      end
+    end
+  end
+end

data/lib/specjour/configuration.rb

@@ -1,105 +1,61 @@
 module Specjour
-  module Configuration
-    extend self
-
-    attr_writer :before_fork, :after_fork, :after_load, :prepare, :rspec_formatter, :rsync_options
-
-    # This block is run by each worker before they begin running tests.
-    # The default action is to migrate the database, and clear it of any old
-    # data.
-    def after_fork
-      @after_fork ||= default_after_fork
-    end
-
-    # This block is run after the manager loads the app into memory, but before
-    # forking new worker processes. The default action is to disconnect from
-    # the ActiveRecord database.
-    def after_load
-      @after_load ||= default_after_load
-    end
-
-    # This block is run by the manager before forking workers. The default
-    # action is to run bundle install.
-    def before_fork
-      @before_fork ||= default_before_fork
-    end
-
-    # This block is run on all workers when invoking `specjour prepare`
-    # Defaults to dropping the worker's database and recreating it. This
-    # is especially useful when two teams are sharing workers and writing
-    # migrations at around the same time causing databases to get out of sync.
-    def prepare
-      @prepare ||= default_prepare
-    end
-
-    def reset
-      @before_fork = nil
-      @after_fork = nil
-      @after_load = nil
-      @prepare = nil
-      @rsync_options = nil
-      @rspec_formatter = nil
-    end
-
-    def rspec_formatter
-      @rspec_formatter ||= default_rspec_formatter
-    end
-
-    def rsync_options
-      @rsync_options ||= default_rsync_options
-    end
-
-    def bundle_install
-      if system('which bundle')
-        system('bundle check') || system('bundle install')
-      end
-    end
-
-    def default_before_fork
-      lambda do
-        bundle_install
-      end
-    end
-
-    def default_after_fork
-      lambda do
-        DbScrub.scrub if rails_with_ar?
-      end
-    end
-
-    def default_after_load
-      lambda do
-        ActiveRecord::Base.remove_connection if rails_with_ar?
-      end
-    end
-
-    def default_prepare
-      lambda do
-        if rails_with_ar?
-          DbScrub.drop
-          DbScrub.scrub
+  class Configuration
+    attr_accessor :options
+
+    DEFAULT_BACKTRACE_EXCLUSION = Regexp.union([
+      "/lib/specjour/",
+      /lib\/rspec\/(core|expectations|matchers|mocks)/,
+      "/gems/",
+      "spec/spec_helper.rb",
+      "spec/rails_helper.rb",
+      "bin/"
+    ]).freeze
+
+    DEFAULT_OPTIONS = {
+      backtrace_exclusion_pattern: DEFAULT_BACKTRACE_EXCLUSION,
+      formatter: Formatter.new,
+      full_backtrace: false,
+      printer_port: nil,
+      printer_uri: nil,
+      project_aliases: [],
+      project_name: nil,
+      project_path: nil,
+      remote_job: nil,
+      rsync_options: "-aL --delete --ignore-errors",
+      rsync_port: 23456,
+      test_paths: nil,
+      tmp_path: "/tmp",
+      worker_size: lambda { Specjour.configuration.remote_job ? CPU.half_cores : CPU.cores },
+      worker_number: 0
+    }.freeze
+
+    def self.make_option(name)
+      define_method(name) do
+        option = @options[name]
+        if option.respond_to?(:call)
+          option.call()
+        else
+          option
         end
       end
-    end
 
-    def default_rspec_formatter
-      lambda do
-        ::RSpec::Core::Formatters::ProgressFormatter
+      define_method("#{name}=") do |value|
+        @options[name] = value
       end
     end
 
-    def default_rsync_options
-      "-aL --delete --ignore-errors"
+    DEFAULT_OPTIONS.each do |k,v|
+      make_option(k)
     end
 
-    protected
-
-    def rails_with_ar?
-      defined?(Rails) && defined?(ActiveRecord::Base)
+    def initialize(options={})
+      @original_options = options
+      set_options
     end
 
-    def system(cmd)
-      Kernel.system("#{cmd} > /dev/null")
+    def set_options
+      @options = DEFAULT_OPTIONS.merge @original_options
     end
+
   end
 end

data/lib/specjour/connection.rb

@@ -1,12 +1,13 @@
 module Specjour
   class Connection
+    include Logger
     include Protocol
     extend Forwardable
 
     attr_reader :uri, :retries
     attr_writer :socket
 
-    def_delegators :socket, :flush, :close, :closed?, :gets, :each
+    def_delegators :socket, :flush, :close, :closed?, :gets, :puts, :each, :eof?, :tty?
 
     def self.wrap(established_connection)
       host, port = established_connection.peeraddr.values_at(3,1)
@@ -23,58 +24,106 @@ module Specjour
     alias to_str to_s
 
     def connect
+      debug "connecting to socket #{host}:#{port}"
       timeout { connect_socket }
     end
 
     def disconnect
-      socket.close if socket && !socket.closed?
+      if socket && !socket.closed?
+        debug "closing socket"
+        socket.close
+      end
+    end
+
+    def host
+      uri.host
+    end
+
+    def port
+      uri.port
     end
 
     def socket
       @socket ||= connect
     end
 
+    def add_to_profiler(test, time, host)
+      send_command("add_to_profiler", test, time, host)
+    end
+
+    def done
+      send_command("done")
+    end
+
+    def error(exception)
+      prefix = if n = ENV["TEST_ENV_NUMBER"]
+                 "[#{n}]"
+               else
+                 ""
+               end
+      send_command("error", "#{prefix}#{exception.inspect}\n#{exception.backtrace.join("\n")}")
+    rescue => error
+      $stderr.puts "Error sending error to server: #{error.inspect}"
+      $stderr.puts error.backtrace
+    end
+
+    def report_test(test)
+      send_command("report_test", test)
+    end
+
     def next_test
-      will_reconnect do
-        send_message(:ready)
-        load_object socket.gets(TERMINATOR)
-      end
+      send_recv_command("next_test")
     end
 
-    def print(arg)
+    def ready(info)
+      send_recv_command("ready", info)
+    end
+
+    def reconnect
+      socket.close unless socket.closed?
+      connect
+    end
+
+    def register_tests(tests)
+      send_command("register_tests", tests)
+    end
+
+    def send_server_done(signal)
+      send_command("server_done", signal)
+    end
+
+    def get_server_done
       will_reconnect do
-        socket.print dump_object(arg)
+        data = recv_data
+        if data[:command] == "server_done"
+          data[:args].first
+        end
       end
     end
 
-    def puts(arg='')
+    def send_command(method_name, *args)
       will_reconnect do
-        print(arg << "\n")
+        send_data command: method_name, args: args
       end
     end
 
-    def send_message(method_name, *args)
+    def send_recv_command(method_name, *args)
+      send_command(method_name, *args)
       will_reconnect do
-        print([method_name, *args])
-        flush
+        recv_data
       end
     end
 
     protected
 
     def connect_socket
-      @socket = TCPSocket.open(uri.host, uri.port)
+      @socket = TCPSocket.open(host, port)
     rescue Errno::ECONNREFUSED => error
       retry
     end
 
-    def reconnect
-      socket.close unless socket.closed?
-      connect
-    end
-
     def timeout(&block)
-      Timeout.timeout(1.0, &block)
+      Timeout.timeout(0.2, &block)
     rescue Timeout::Error
     end
 

data/lib/specjour/cpu.rb

@@ -10,6 +10,10 @@ module Specjour
       end
     end
 
+    def self.half_cores
+      cores / 2
+    end
+
     protected
 
     def self.command(cmd)

data/lib/specjour/fork.rb

@@ -10,7 +10,7 @@ module Specjour::Fork
       at_exit { exit! }
       begin
         yield
-      rescue StandardError => e
+      rescue Exception => e
         $stderr.puts "#{e.class} #{e.message}", e.backtrace
       end
     end