specjour 0.7.0 → 2.0.0.rc1

data/lib/specjour/formatter.rb

@@ -0,0 +1,153 @@
+module Specjour
+  class Formatter
+    require 'json'
+    include Colors
+    # description, status [pending,failed,passed] file_path, line_number, exception => [class, message, backtrace]
+
+    STATUSES = Hash.new({char: "?", color: :white}).merge!(
+      "passed" => {char: ".", color: :green},
+      "failed" => {char: "F", color: :red},
+      "error" => {char: "E", color: :magenta},
+      "pending" => {char: "P", color: :yellow},
+      "other" => {char: "O", color: :white}
+    )
+
+    attr_accessor \
+      :error_count,
+      :fail_count,
+      :failures,
+      :output,
+      :pass_count,
+      :pending_count,
+      :start_time,
+      :end_time,
+      :tests
+
+    def initialize(output=$stdout)
+      @output = output
+      @tests = []
+      @failures = []
+      @pass_count, @pending_count, @fail_count, @error_count = 0, 0, 0, 0
+      @start_time = Time.now
+    end
+
+    def print(test)
+      if test[:status] == "failed"
+        @output.puts
+        print_failure(test, fail_count)
+      else
+        status_format = STATUSES[test[:status]]
+        @output.print colorize(status_format[:char], status_format[:color])
+      end
+    end
+
+    def print_failures
+      @output.puts "Failures:\n\n"
+      failures.each_with_index do |test, index|
+        print_failure(test, index)
+      end
+    end
+
+    def print_failure(test, index)
+      exception = test[:exception]
+      num = index + 1
+      indent = num.to_s.size + 2
+      worker = "#{test[:hostname]}[#{test[:worker_number]}]"
+      @output.puts colorize("#{num}. #{worker}", :red)
+      description = colorize("#{test[:description]}", :red)
+      @output.print " " * indent
+      @output.puts description
+      message = colorize("#{exception[:class]}: #{exception[:message]}", :red)
+      @output.print " " * indent
+      @output.puts message
+      @output.puts format_backtrace(exception[:backtrace])
+      @output.puts
+    end
+
+    def format_backtrace(backtrace)
+      backtrace = Array(backtrace)
+      if Specjour.configuration.full_backtrace
+        backtrace
+      else
+        backtrace.reject {|l| Specjour.configuration.backtrace_exclusion_pattern =~ l}
+      end
+    end
+
+    def failing_test_paths
+      failures.map do |f|
+        "#{f[:file_path]}:#{f[:line_number]}"
+      end.uniq
+    end
+
+
+    def print_counts
+      @output.puts colorize("Pending: #{pending_count}", :yellow)
+      @output.puts colorize("Errors: #{error_count}", :magenta)
+      @output.puts colorize("Passed: #{pass_count}", :green)
+      @output.puts colorize("Failed: #{fail_count}", :red)
+    end
+
+    def execution_time
+      Time.new(2000,1,1,0,0,0,0) + (end_time - start_time)
+    end
+
+    def print_overview
+      overall_color = fail_count == 0 ? :green : :red
+      @output.puts colorize("\nRan: #{tests.size} tests in #{execution_time.strftime("%Mm:%Ss:%Lms")}", overall_color)
+    end
+
+    def print_summary
+      @output.puts "\n\n"
+      print_failures if failures.any?
+      print_counts
+      print_overview
+      @output.puts "\n"
+    end
+
+    def report_test(test)
+      print(test)
+      tests << test
+      case test[:status]
+      when "passed"
+        @pass_count += 1
+      when "failed"
+        @fail_count += 1
+        failures << test
+      when "error"
+        @error_count += 1
+      when "pending"
+        @pending_count += 1
+      end
+    end
+
+    def set_end_time!
+      @end_time = Time.now
+    end
+
+    def exit_status
+      failures.any? ? 1 : 0
+    end
+
+  end
+end
+__END__
+Pending:
+  Specjour pends as an example
+    # No reason given
+    # ./spec/specjour_spec.rb:25
+
+Failures:
+
+  1) Specjour fails as an example
+     Failure/Error: raise CustomException, 'fails'
+     CustomException:
+       fails
+     # ./spec/specjour_spec.rb:7:in `boo'
+     # ./spec/specjour_spec.rb:30:in `block (2 levels) in <top (required)>'
+
+Finished in 0.00297 seconds
+14 examples, 1 failure, 1 pending
+
+Failed examples:
+
+rspec ./spec/specjour_spec.rb:29 # Specjour fails as an example

data/lib/specjour/listener.rb

@@ -0,0 +1,181 @@
+module Specjour
+  class Listener
+    require 'dnssd'
+    Thread.abort_on_exception = true
+
+    LOCK_FILE = "listener.lock"
+
+    include Logger
+    include SocketHelper
+
+    attr_accessor :options, :printer
+
+    def self.ensure_started
+      listener = new
+      unless listener.started?
+        listener_pid = fork do
+          Specjour.plugin_manager.send_task(:remove_connection)
+          listener.daemonize
+          listener.start
+        end
+        Process.detach(listener_pid)
+      end
+      listener
+    end
+
+    def initialize(options={})
+      self.options = options
+    end
+
+    def available_for?(project_name)
+      if Specjour.configuration.project_aliases.any? || !project_name.empty?
+        Specjour.configuration.project_aliases.include? project_name
+      else
+        true
+      end
+    end
+
+    def config_directory
+      return @config_directory if @config_directory
+      @config_directory = File.join(Dir.tmpdir, "specjour")
+      FileUtils.mkdir_p @config_directory
+      @config_directory
+    end
+
+    def daemonize
+      Process.daemon
+    end
+
+    def add_printer(params)
+      log "Listener adding printer #{params}"
+      self.printer = params
+      Specjour.configuration.printer_uri = params[:uri]
+      Specjour.configuration.remote_job = remote_ip?(params[:ip])
+    end
+
+    def remove_printer
+      self.printer = nil
+      Specjour.configuration.printer_uri = nil
+      Specjour.configuration.remote_job = nil
+    end
+
+    def fork_loader
+      Specjour.plugin_manager.send_task(:before_loader_fork)
+      fork do
+        Specjour.plugin_manager.send_task(:remove_connection)
+        loader = Loader.new({task: "run_tests"})
+        Specjour.plugin_manager.send_task(:after_loader_fork)
+        loader.start
+      end
+    end
+
+    def gather
+      @dnssd_service = DNSSD.browse!('_specjour._tcp') do |reply|
+        log ['reply', reply.name, reply.service_name, reply.domain,reply.flags, reply.interface]
+        if reply.flags.add?
+          DNSSD.resolve!(reply.name, reply.type, reply.domain, flags=0, reply.interface) do |resolved|
+            log "Bonjour discovered #{resolved.target} #{resolved.text_record.inspect}"
+            if resolved.text_record && resolved.text_record['version'] == Specjour::VERSION
+              if available_for?(resolved.text_record['project_alias'].to_s)
+                resolved_ip = ip_from_hostname(resolved.target)
+                uri = URI::Generic.build :host => resolved_ip, :port => resolved.port
+                add_printer(name: resolved.name, uri: uri, ip: resolved_ip)
+              else
+                $stderr.puts "Found #{resolved.target} but not listening to project alias: #{resolved.text_record['project_alias']}. Skipping..."
+              end
+            else
+              $stderr.puts "Found #{resolved.target} but its version doesn't match v#{Specjour::VERSION}. Skipping..."
+            end
+            break
+          end
+          break if printer
+        else
+          log "REMOVING #{reply.name} #{reply}"
+          remove_printer
+        end
+      end
+    end
+
+    def pid
+      if File.exist?(pid_file) && !File.directory?(pid_file)
+        File.read(pid_file).strip.to_i
+      end
+    end
+
+    def pid_file
+      @pid_file ||= File.join(config_directory, "#{Specjour.configuration.project_aliases.join("-")}.pid")
+    end
+
+    def lock_file
+      @lock_file ||= File.join(config_directory, LOCK_FILE)
+    end
+
+    # only allow one listener to execute at a time
+    def listener_lock(&block)
+      exception = nil
+      File.open(lock_file, "w") do |file|
+        begin
+          debug "Acquiring listener lock"
+          file.flock File::LOCK_EX
+          debug "Listener lock acquired"
+          block.call
+        rescue => exception
+          file.flock File::LOCK_UN
+        end
+      end
+      raise exception if exception
+    end
+
+    def program_name
+      name = "specjour listen"
+      if Specjour.configuration.project_aliases.any?
+        name += " -a #{Specjour.configuration.project_aliases.join(",")}"
+      end
+      name
+    end
+
+    def start
+      $PROGRAM_NAME = program_name
+      log "Listener starting"
+      write_pid
+      loop do
+        log "listening..."
+        gather
+        listener_lock do
+          @loader_pid = fork_loader
+          Process.waitall
+          remove_printer
+          sleep 3 # let bonjour services stop
+        end
+      end
+    rescue StandardError, ScriptError => e
+      $stderr.puts "RESCUED #{e.message}"
+      $stderr.puts e.backtrace
+      connection.error(e)
+    ensure
+      remove_pid
+      remove_connection
+      log "Shutting down listener"
+    end
+
+    def started?
+      !pid.nil?
+    end
+
+    def stop
+      Process.kill("TERM", pid) rescue TypeError
+    ensure
+      remove_pid
+    end
+
+    def write_pid
+      File.open(pid_file, 'w') do |f|
+        f.write Process.pid
+      end
+    end
+
+    def remove_pid
+      File.unlink(pid_file) if File.exist?(pid_file) && pid == Process.pid
+    end
+  end
+end

data/lib/specjour/loader.rb

@@ -1,150 +1,86 @@
 module Specjour
+  require 'specjour/worker'
   class Loader
-    include Protocol
-    include Fork
+    include Logger
+    include SocketHelper
 
-    attr_reader :test_paths, :printer_uri, :project_path, :task, :worker_size, :worker_pids, :quiet
+    attr_reader \
+      :options,
+      :quiet,
+      :task,
+      :worker_pids
 
     def initialize(options = {})
       @options = options
-      @printer_uri = options[:printer_uri]
-      @test_paths = options[:test_paths]
-      @worker_size = options[:worker_size]
       @task = options[:task]
       @quiet = options[:quiet]
-      @project_path = options[:project_path]
       @worker_pids = []
-      Dir.chdir project_path
-      Specjour.load_custom_hooks
     end
 
     def start
-      load_app
-      Configuration.after_load.call
-      (1..worker_size).each do |index|
-        worker_pids << fork do
-          Worker.new(
-            :number => index,
-            :printer_uri => printer_uri,
-            :quiet => quiet
-          ).send(task)
-        end
-      end
-      Process.waitall
+      Process.setsid
+      $PROGRAM_NAME = "specjour loader"
+      set_up
+      sync
+      Specjour.plugin_manager.send_task(:load_application)
+      Specjour.plugin_manager.send_task(:register_tests_with_printer)
+      fork_workers
+      wait_srv
+    rescue StandardError, ScriptError => e
+      $stderr.puts "RESCUED #{e.class} '#{e.message}'"
+      $stderr.puts e.backtrace
+      $stderr.puts "\n\n"
+      connection.error(e)
     ensure
-      kill_worker_processes
-    end
-
-    def spec_files
-      @spec_files ||= file_collector(spec_paths) do |path|
-        if path == project_path
-          Dir["spec/**/*_spec.rb"]
-        else
-          Dir["**/*_spec.rb"]
-        end
-      end
+      remove_connection
+      log "Loader killing group #{Process.getsid}"
     end
 
-    def feature_files
-      @feature_files ||= file_collector(feature_paths) do |path|
-        if path == project_path
-          Dir["features/**/*.feature"]
-        else
-          Dir["**/*.feature"]
+    def fork_workers
+      Specjour.plugin_manager.send_task(:before_worker_fork)
+      (1..Specjour.configuration.worker_size).each do |index|
+        worker_pids << fork do
+          remove_connection
+          Specjour.plugin_manager.send_task(:remove_connection)
+          $PROGRAM_NAME = "specjour worker"
+          worker = Worker.new(
+            :number => index,
+            :quiet => quiet
+          )
+          Specjour.plugin_manager.send_task(:after_worker_fork)
+          worker.send(task)
         end
       end
     end
 
-    protected
-
-    def spec_paths
-      @spec_paths ||= test_paths.select {|p| p =~ /spec.*$/}
-    end
-
-    def feature_paths
-      @feature_paths ||= test_paths.select {|p| p =~ /features.*$/}
-    end
-
-    def file_collector(paths, &globber)
-      if spec_paths.empty? && feature_paths.empty?
-        globber[project_path]
-      else
-        paths.map do |path|
-          path = File.expand_path(path, project_path)
-          if File.directory?(path)
-            globber[path]
-          else
-            path
-          end
-        end.flatten.uniq
-      end
-    end
-
-    def load_app
-      RSpec::Preloader.load spec_files if spec_files.any?
-      Cucumber::Preloader.load(feature_files, connection) if feature_files.any?
-      register_tests_with_printer
-    end
-
-    def register_tests_with_printer
-      tests = rspec_examples | cucumber_scenarios
-      connection.send_message :tests=, tests
-    end
-
-    def rspec_examples
-      if spec_files.any?
-        filtered_examples
-      else
-        []
-      end
-    end
-
-    def filtered_examples
-      examples = ::RSpec.world.example_groups.map do |g|
-        g.descendant_filtered_examples
-      end.flatten
-      locations = examples.map do |e|
-        meta = e.metadata
-        groups = e.example_group.parent_groups + [e.example_group]
-        shared_group = groups.detect do |group|
-          group.metadata[:shared_group_name]
-        end
-        if shared_group
-          meta = shared_group.metadata[:example_group]
+    def wait_srv
+      select [connection.socket]
+      if !connection.socket.eof?
+        signal = connection.get_server_done
+        case signal
+        when "INT"
+          debug "Sending INT to -#{Process.getsid}"
+          Process.kill("INT", -Process.getsid)
         end
-        meta[:location]
-      end
-    ensure
-      ::RSpec.reset
-    end
-
-    def cucumber_scenarios
-      if feature_files.any?
-        scenarios
-      else
-        []
       end
     end
 
-    def scenarios
-      Cucumber.runtime.send(:features).map do |feature|
-        feature.feature_elements.map do |scenario|
-          "#{feature.file}:#{scenario.instance_variable_get(:@line)}"
-        end
-      end.flatten
+    def set_up
+      data = connection.ready({hostname: hostname, worker_size: Specjour.configuration.worker_size})
+      Specjour.configuration.project_name = data[:project_name]
+      Specjour.configuration.test_paths = data[:test_paths]
+      Specjour.configuration.project_path = File.expand_path(Specjour.configuration.project_name, Specjour.configuration.tmp_path)
     end
 
-    def kill_worker_processes
-      signal = Specjour.interrupted? ? 'INT' : 'TERM'
-      Process.kill(signal, *worker_pids) rescue Errno::ESRCH
+    def sync
+      cmd "rsync #{Specjour.configuration.rsync_options} --port=#{Specjour.configuration.rsync_port} #{connection.host}::#{Specjour.configuration.project_name} #{Specjour.configuration.project_path}"
+      Dir.chdir Specjour.configuration.project_path
     end
 
-    def connection
-      @connection ||= begin
-        at_exit { connection.disconnect }
-        Connection.new URI.parse(printer_uri)
+    def cmd(command)
+      Specjour.benchmark(command) do
+        system *command.split
       end
     end
-
   end
 end

data/lib/specjour/logger.rb

@@ -0,0 +1,34 @@
+module Specjour
+  module Logger
+
+    def log(msg)
+      Specjour.logger.info(self.class.name) { format(msg) }
+    end
+
+    def debug(msg)
+      Specjour.logger.debug(self.class.name) { format("#{msg}\n\t#{called_from}") }
+    end
+
+    private
+
+    def format(msg)
+      prefix = Specjour.configuration.worker_number > 0 ? "[#{Specjour.configuration.worker_number}] " : ""
+      "#{prefix}#{msg}"
+    end
+
+    def called_from
+      caller.detect {|s| s =~ /specjour\/lib\/specjour\/(?!logger\.rb)/}
+    end
+
+    # def self.extended(base)
+    #   base.instance_methods.each do |instance_method|
+    #     define_method instance_method do |*args|
+    #       log __method__
+    #       val = super *args
+    #       log val
+    #       val
+    #     end
+    #   end
+    # end
+  end
+end

data/lib/specjour/plugin/base.rb

@@ -0,0 +1,61 @@
+module Specjour
+  module Plugin
+    class Base
+      include SocketHelper
+      include Specjour::Logger
+
+      attr_reader :listener, :loader, :worker
+
+      def after_register
+      end
+
+      def before_suite
+      end
+
+      def after_suite
+      end
+
+      def before_loader_fork
+      end
+
+      def load_application
+      end
+
+      def load_test_suite
+      end
+
+      def after_loader_fork
+      end
+
+      def before_worker_fork
+      end
+
+      def after_worker_fork
+      end
+
+      def interrupted!
+      end
+
+      def register_tests_with_printer
+      end
+
+      def run_test(test)
+        false
+      end
+
+      def tests_to_register
+        []
+      end
+
+      def before_print_summary(formatter)
+      end
+
+      def after_print_summary(formatter)
+      end
+
+      def exit_status(formatter)
+      end
+
+    end
+  end
+end

data/lib/specjour/plugin/manager.rb

@@ -0,0 +1,28 @@
+module Specjour::Plugin
+  class Manager
+    include Specjour::Logger
+    attr_reader :plugins
+
+    def initialize
+      @plugins = []
+    end
+
+    def register_plugin(plugin, position=-1)
+      if !plugins.include?(plugin)
+        plugins.insert(position, plugin)
+      end
+    end
+
+    def clear_plugins
+      plugins.clear
+    end
+
+    def send_task(task, *args)
+      plugins.map do |plugin|
+        log "sending task to plugin: #{task}, #{plugin}"
+        plugin.__send__(task, *args)
+        # break if plugin.__send__(task, *args) == false
+      end
+    end
+  end
+end