JonathanTron-specjour 0.2.5.1

data/lib/specjour/connection.rb

@@ -0,0 +1,85 @@
+module Specjour
+  class Connection
+    include Protocol
+    extend Forwardable
+
+    attr_reader :uri
+    attr_writer :socket
+
+    def_delegators :socket, :flush, :closed?, :gets, :each
+
+    def self.wrap(established_connection)
+      host, port = established_connection.peeraddr.values_at(3,1)
+      connection = new URI::Generic.build(:host => host, :port => port)
+      connection.socket = established_connection
+      connection
+    end
+
+    def initialize(uri)
+      @uri = uri
+    end
+
+    alias to_str to_s
+
+    def connect
+      timeout { connect_socket }
+    end
+
+    def disconnect
+      socket.close
+    end
+
+    def socket
+      @socket ||= connect
+    end
+
+    def timeout(&block)
+      Timeout.timeout(2, &block)
+    rescue Timeout::Error
+      raise Error, "Connection to dispatcher timed out"
+    end
+
+    def next_test
+      will_reconnect do
+        send_message(:ready)
+        load_object socket.gets(TERMINATOR)
+      end
+    end
+
+    def print(arg)
+      will_reconnect do
+        socket.print dump_object(arg)
+      end
+    end
+
+    def puts(arg)
+      print(arg << "\n")
+    end
+
+    def send_message(method_name, *args)
+      print([method_name, *args])
+      flush
+    end
+
+    protected
+
+    def connect_socket
+      @socket = TCPSocket.open(uri.host, uri.port)
+    rescue Errno::ECONNREFUSED => error
+      Specjour.logger.debug "Could not connect to #{uri.to_s}\n#{error.inspect}"
+      retry
+    end
+
+    def reconnect
+      socket.close unless socket.closed?
+      connect
+    end
+
+    def will_reconnect(&block)
+      block.call
+    rescue SystemCallError => error
+      reconnect
+      retry
+    end
+  end
+end

data/lib/specjour/cpu.rb

@@ -0,0 +1,19 @@
+module Specjour
+  module CPU
+    def self.cores
+      case RUBY_PLATFORM
+      when /darwin/
+        command('hostinfo') =~ /^(\d+).+logically/
+        $1.to_i
+      when /linux/
+        command('grep --count processor /proc/cpuinfo').to_i
+      end
+    end
+
+    protected
+
+    def self.command(cmd)
+      %x(#{cmd})
+    end
+  end
+end

data/lib/specjour/cucumber.rb

@@ -0,0 +1,14 @@
+module Specjour
+  module Cucumber
+    begin
+      require 'cucumber'
+      require 'cucumber/formatter/progress'
+
+      require 'specjour/cucumber/dispatcher'
+      require 'specjour/cucumber/distributed_formatter'
+      require 'specjour/cucumber/final_report'
+      require 'specjour/cucumber/printer'
+    rescue LoadError
+    end
+  end
+end

data/lib/specjour/cucumber/dispatcher.rb

@@ -0,0 +1,18 @@
+module Specjour
+  module Cucumber
+    class Dispatcher < ::Specjour::Dispatcher
+
+      protected
+
+      def all_specs
+        @all_specs ||= Dir.chdir(project_path) do
+          Dir["features/**/*.feature"]
+        end
+      end
+
+      def printer
+        @printer ||= Printer.start(all_specs)
+      end
+    end
+  end
+end

data/lib/specjour/cucumber/distributed_formatter.rb

@@ -0,0 +1,84 @@
+module Specjour::Cucumber
+  class DistributedFormatter < ::Cucumber::Formatter::Progress
+    class << self
+      attr_accessor :batch_size
+    end
+    @batch_size = 1
+
+    def initialize(step_mother, io, options)
+      @step_mother = step_mother
+      @io = io
+      @options = options
+      @failing_scenarios = []
+      @step_summary = []
+    end
+
+    def after_features(features)
+      print_summary
+      step_mother.scenarios.clear
+      step_mother.steps.clear
+    end
+
+    def prepare_failures
+      @failures = step_mother.scenarios(:failed).select { |s| s.is_a?(Cucumber::Ast::Scenario) }
+
+      if !@failures.empty?
+        @failures.each do |failure|
+          failure_message = ''
+          failure_message += format_string("cucumber " + failure.file_colon_line, :failed) +
+          failure_message += format_string(" # Scenario: " + failure.name, :comment)
+          @failing_scenarios << failure_message
+        end
+      end
+    end
+
+    def prepare_elements(elements, status, kind)
+      output = ''
+      if elements.any?
+        output += format_string("\n(::) #{status} #{kind} (::)\n", status)
+        output += "\n"
+      end
+
+      elements.each_with_index do |element, i|
+        if status == :failed
+          output += print_exception(element.exception, status, 0)
+        else
+          output += format_string(element.backtrace_line, status)
+          output += "\n"
+        end
+        @step_summary << output unless output.blank?
+      end
+    end
+
+    def prepare_steps(type)
+      prepare_elements(step_mother.scenarios(type), type, 'steps')
+    end
+
+    def print_exception(e, status, indent)
+      format_string("#{e.message} (#{e.class})\n#{e.backtrace.join("\n")}".indent(indent), status)
+    end
+
+    def print_summary
+      prepare_failures
+      prepare_steps(:failed)
+      prepare_steps(:undefined)
+
+      @io.send_message(:worker_summary=, to_hash)
+    end
+
+    OUTCOMES = [:failed, :skipped, :undefined, :pending, :passed]
+
+    def to_hash
+      hash = {}
+      [:scenarios, :steps].each do |type|
+        hash[type] = {}
+        OUTCOMES.each do |outcome|
+          hash[type][outcome] = step_mother.send(type, outcome).size
+        end
+      end
+      hash.merge!(:failing_scenarios => @failing_scenarios, :step_summary => @step_summary)
+      hash
+    end
+
+  end
+end

data/lib/specjour/cucumber/final_report.rb

@@ -0,0 +1,79 @@
+module Specjour
+  module Cucumber
+    class Summarizer
+      attr_reader :duration, :failing_scenarios, :step_summary
+      def initialize
+        @duration = 0.0
+        @failing_scenarios = []
+        @step_summary = []
+        @scenarios = Hash.new(0)
+        @steps = Hash.new(0)
+      end
+
+      def increment(category, type, count)
+        current = instance_variable_get("@#{category}")
+        current[type] += count
+      end
+
+      def add(stats)
+        stats.each do |category, hash|
+          if category == :failing_scenarios
+            @failing_scenarios += hash
+          elsif category == :step_summary
+            @step_summary += hash
+          elsif category == :duration
+            @duration = hash.to_f if duration < hash.to_f
+          else
+            hash.each do |type, count|
+              increment(category, type, count)
+            end
+          end
+        end
+      end
+
+      def scenarios(status=nil)
+        length = status ? @scenarios[status] : @scenarios.inject(0) {|h,(k,v)| h += v}
+        any = @scenarios[status] > 0 if status
+        OpenStruct.new(:length => length , :any? => any)
+      end
+
+      def steps(status=nil)
+        length = status ? @steps[status] : @steps.inject(0) {|h,(k,v)| h += v}
+        any = @steps[status] > 0 if status
+        OpenStruct.new(:length => length , :any? => any)
+      end
+    end
+
+    class FinalReport
+      include ::Cucumber::Formatter::Console
+      def initialize
+        @features = []
+        @summarizer = Summarizer.new
+      end
+
+      def add(stats)
+        @summarizer.add(stats)
+      end
+
+      def exit_status
+        @summarizer.failing_scenarios.empty?
+      end
+
+      def summarize
+        if @summarizer.failing_scenarios.any?
+          puts "\n\n"
+          @summarizer.step_summary.each {|f| puts f }
+          puts "\n\n"
+          puts format_string("Failing Scenarios:", :failed)
+          @summarizer.failing_scenarios.each {|f| puts f }
+        end
+
+        default_format = lambda {|status_count, status| format_string(status_count, status)}
+        puts
+        puts scenario_summary(@summarizer, &default_format)
+        puts step_summary(@summarizer, &default_format)
+        puts format_duration(@summarizer.duration) if @summarizer.duration
+      end
+    end
+  end
+end

data/lib/specjour/cucumber/printer.rb

@@ -0,0 +1,9 @@
+module Specjour
+  module Cucumber
+    class Printer < ::Specjour::Printer
+      def report
+        @report ||= FinalReport.new
+      end
+    end
+  end
+end

data/lib/specjour/db_scrub.rb

@@ -0,0 +1,47 @@
+module Specjour
+  module DbScrub
+    require 'rake'
+    load 'tasks/misc.rake'
+    load 'tasks/databases.rake'
+
+    extend self
+
+    def scrub
+      connect_to_database
+      if pending_migrations?
+        puts "Migrating schema for database #{ENV['TEST_ENV_NUMBER']}..."
+        Rake::Task['db:test:load'].invoke
+      else
+        purge_tables
+      end
+    end
+
+    protected
+
+    def connect_to_database
+      connection
+    rescue # assume the database doesn't exist
+      Rake::Task['db:create'].invoke
+    end
+
+    def connection
+      ActiveRecord::Base.connection
+    end
+
+    def purge_tables
+      connection.disable_referential_integrity do
+        tables_to_purge.each do |table|
+          connection.delete "delete from #{table}"
+        end
+      end
+    end
+
+    def pending_migrations?
+      ActiveRecord::Migrator.new(:up, 'db/migrate').pending_migrations.any?
+    end
+
+    def tables_to_purge
+      connection.tables - ['schema_migrations']
+    end
+  end
+end

data/lib/specjour/dispatcher.rb

@@ -0,0 +1,119 @@
+module Specjour
+  class Dispatcher
+    require 'dnssd'
+    Thread.abort_on_exception = true
+    include SocketHelpers
+
+    class << self
+      attr_accessor :interrupted
+      alias interrupted? interrupted
+    end
+
+    attr_reader :project_path, :managers, :manager_threads, :hosts
+    attr_accessor :worker_size
+
+    def initialize(project_path)
+      @project_path = project_path
+      @managers = []
+      @worker_size = 0
+      reset_manager_threads
+    end
+
+    def start
+      rsync_daemon.start
+      gather_managers
+      dispatch_work
+      printer.join
+      exit printer.exit_status
+    end
+
+    protected
+
+    def all_specs
+      @all_specs ||= Dir.chdir(project_path) do
+        Dir["spec/**/**/*_spec.rb"].sort
+      end
+    end
+
+    def command_managers(async = false, &block)
+      managers.each do |manager|
+        manager_threads << Thread.new(manager, &block)
+      end
+      wait_on_managers unless async
+    end
+
+    def dispatch_work
+      command_managers(true) { |m| m.dispatch }
+    end
+
+    def fetch_manager(uri)
+      Timeout.timeout(8) do
+        manager = DRbObject.new_with_uri(uri.to_s)
+        if !managers.include?(manager) && manager.available_for?(project_name)
+          set_up_manager(manager, uri)
+          managers << manager
+          self.worker_size += manager.worker_size
+        end
+      end
+    rescue Timeout::Error
+      Specjour.logger.debug "Couldn't work with manager at #{uri}"
+    end
+
+    def gather_managers
+      puts "Waiting for managers"
+      Signal.trap('INT') { self.class.interrupted = true; exit }
+      browser = DNSSD::Service.new
+      begin
+        Timeout.timeout(10) do
+          browser.browse '_druby._tcp' do |reply|
+            if reply.flags.add?
+              resolve_reply(reply)
+            end
+            browser.stop unless reply.flags.more_coming?
+          end
+        end
+      rescue Timeout::Error
+      end
+      puts "Managers found: #{managers.size}"
+      abort unless managers.size > 0
+      puts "Workers found: #{worker_size}"
+      printer.worker_size = worker_size
+    end
+
+    def printer
+      @printer ||= Printer.start(all_specs)
+    end
+
+    def project_name
+      @project_name ||= (ENV["SPECJOUR_PROJECT_NAME"] || File.basename(project_path))
+    end
+
+    def reset_manager_threads
+      @manager_threads = []
+    end
+
+    def resolve_reply(reply)
+      DNSSD.resolve!(reply) do |resolved|
+        resolved_ip = ip_from_hostname(resolved.target)
+        uri = URI::Generic.build :scheme => reply.service_name, :host => resolved_ip, :port => resolved.port
+        fetch_manager(uri)
+        resolved.service.stop if resolved.service.started?
+      end
+    end
+
+    def rsync_daemon
+      @rsync_daemon ||= RsyncDaemon.new(project_path, project_name)
+    end
+
+    def set_up_manager(manager, uri)
+      manager.project_name = project_name
+      manager.dispatcher_uri = URI::Generic.build :scheme => "specjour", :host => hostname, :port => printer.port
+      at_exit { manager.kill_worker_processes }
+    end
+
+    def wait_on_managers
+      manager_threads.each {|t| t.join; t.exit}
+      reset_manager_threads
+    end
+  end
+end