brynary-testjour 0.1.0

data/lib/testjour/commands/slave_run.rb

@@ -0,0 +1,88 @@
+require "drb"
+require "uri"
+
+require "testjour/commands/base_command"
+require "testjour/rsync"
+require "testjour/queue_server"
+require "testjour/cucumber_extensions/drb_formatter"
+require "testjour/mysql"
+
+module Testjour
+  module CLI
+  
+    class SlaveRun < BaseCommand
+      def self.command
+        "slave:run"
+      end
+      
+      def initialize(parser, args)
+        Testjour.logger.debug "Runner command #{self.class}..."
+        super
+        @queue = @non_options.first
+      end
+  
+      def run
+        retryable :tries => 2, :on => RsyncFailed do
+          Testjour::Rsync.copy_to_current_directory_from(@queue)
+        end
+        
+        ARGV.clear # Don't pass along args to RSpec
+        Testjour.load_cucumber
+        
+        ENV["RAILS_ENV"] = "test"
+        require File.expand_path("config/environment")
+        
+        Testjour::MysqlDatabaseSetup.with_new_database do
+          Cucumber::CLI.executor.formatters = Testjour::DRbFormatter.new(queue_server)
+          require_files
+
+          begin
+            loop do
+              begin
+                run_file(queue_server.take_work)
+              rescue Testjour::QueueServer::NoWorkUnitsAvailableError
+                # If no work, ignore and keep looping
+              end
+            end
+          rescue DRb::DRbConnError
+            Testjour.logger.debug "DRb connection error. (This is normal.) Exiting runner."
+          end
+        end
+      end
+      
+      def require_files
+        cli = Cucumber::CLI.new
+        cli.parse_options!(@non_options)
+        cli.send(:require_files)
+      end
+  
+      def run_file(file)
+        Testjour.logger.debug "Running feature file: #{file}"
+        features = feature_parser.parse_feature(File.expand_path(file))
+        Cucumber::CLI.executor.visit_features(features)
+      end
+      
+      def queue_server
+        @queue_server ||= begin
+          DRb.start_service
+          DRbObject.new(nil, drb_uri)
+        end
+      end
+      
+      def drb_uri
+        uri = URI.parse(@queue)
+        uri.scheme = "druby"
+        uri.path = ""
+        uri.user = nil
+        uri.to_s
+      end
+  
+      def feature_parser
+        @feature_parser ||= Cucumber::TreetopParser::FeatureParser.new
+      end
+  
+    end
+
+    Parser.register_command SlaveRun
+  end
+end

data/lib/testjour/commands/slave_start.rb

@@ -0,0 +1,65 @@
+require "drb"
+
+require "testjour/commands/base_command"
+require "daemons/daemonize"
+require "testjour/pid_file"
+require "testjour/slave_server"
+require "testjour/bonjour"
+
+module Testjour
+  module CLI
+    
+    class SlaveStart < BaseCommand
+      class StopServer < Exception
+      end
+      
+      def self.command
+        "slave:start"
+      end
+      
+      def initialize(*args)
+        Testjour.logger.debug "Runner command #{self.class}..."
+        super
+      end
+      
+      def run
+        verify_not_a_git_repo
+        
+        original_working_directory = File.expand_path(".")
+        
+        pid_file = PidFile.new("./testjour_slave.pid")
+        pid_file.verify_doesnt_exist
+        at_exit { pid_file.remove }
+        register_signal_handler
+
+        logfile = File.expand_path("./testjour.log")
+        Daemonize.daemonize(logfile)
+        
+        Dir.chdir(original_working_directory)
+        pid_file.write
+        
+        Testjour.setup_logger
+        Testjour::Bonjour.serve(Testjour::SlaveServer.start)
+        DRb.thread.join
+      rescue StopServer
+        exit 0
+      end
+      
+      def verify_not_a_git_repo
+        return unless File.exists?("./.git")
+        puts "!!! This directory looks like a git repository. This probably isn't where you want to start a testjour slave"
+        exit 1
+      end
+      
+      def register_signal_handler
+        trap("TERM") do
+          Testjour.logger.info "TERM signal received."
+          raise StopServer.new
+        end
+      end
+      
+    end
+    
+    Parser.register_command SlaveStart
+  end
+end

data/lib/testjour/commands/slave_stop.rb

@@ -0,0 +1,25 @@
+require "testjour/commands/base_command"
+require "testjour/pid_file"
+
+module Testjour
+  module CLI
+    
+    class SlaveStop < BaseCommand
+      def self.command
+        "slave:stop"
+      end
+      
+      def initialize(*args)
+        Testjour.logger.debug "Runner command #{self.class}..."
+        super
+      end
+      
+      def run
+        pid_file = PidFile.new("./testjour_slave.pid")
+        pid_file.send_signal("TERM")
+      end
+    end
+    
+    Parser.register_command SlaveStop
+  end
+end

data/lib/testjour/commands/slave_warm.rb

@@ -0,0 +1,31 @@
+require "drb"
+require "uri"
+
+require "testjour/commands/base_command"
+require "testjour/rsync"
+
+module Testjour
+  module CLI
+  
+    class SlaveWarm < BaseCommand
+      def self.command
+        "slave:warm"
+      end
+      
+      def initialize(parser, args)
+        Testjour.logger.debug "Runner command #{self.class}..."
+        super
+        @queue = @non_options.first
+      end
+  
+      def run
+        retryable :tries => 2, :on => RsyncFailed do
+          Testjour::Rsync.copy_to_current_directory_from(@queue)
+        end
+      end
+  
+    end
+
+    Parser.register_command SlaveWarm
+  end
+end

data/lib/testjour/commands/version.rb

@@ -0,0 +1,18 @@
+require "testjour/commands/base_command"
+
+module Testjour
+  module CLI
+
+    class VersionCommand < BaseCommand
+      def self.command
+        "version"
+      end
+  
+      def run
+        puts "Testjour #{Testjour::VERSION}"
+      end
+    end
+    
+    Parser.register_command VersionCommand
+  end
+end

data/lib/testjour/commands/warm.rb

@@ -0,0 +1,73 @@
+require "drb"
+
+require "testjour/commands/base_command"
+require "testjour/bonjour"
+
+module Testjour
+  module CLI
+    
+    class Warm < BaseCommand
+      def self.command
+        "warm"
+      end
+      
+      def initialize(*args)
+        Testjour.logger.debug "Runner command #{self.class}..."
+        
+        super
+        @found_server = 0
+        require "testjour/colorer"
+      end
+      
+      def run
+        if available_servers.any?
+          available_servers.each do |server|
+            request_warm_from(server)
+          end
+          
+          print_results
+        else
+          puts
+          puts Testjour::Colorer.failed("Don't see any available test servers. Try again later.")
+        end
+      end
+      
+      def available_servers
+        @available_servers ||= Testjour::Bonjour.list
+      end
+      
+      def request_warm_from(server)
+        slave_server = DRbObject.new(nil, server.uri)
+        result = slave_server.warm(testjour_uri)
+  
+        if result
+          Testjour.logger.info "Requesting warm from available server: #{server.uri}. Accepted."
+          @found_server += 1
+        else
+          Testjour.logger.info "Requesting warm from available server: #{server.uri}. Rejected."
+        end
+      end
+      
+      def print_results
+        if @found_server > 0
+          puts
+          puts "#{@found_server} slave accepted the warm request."
+        else
+          puts
+          puts Testjour::Colorer.failed("Found available servers, but none accepted the warm request. Try again later.")
+        end
+      end
+      
+      def testjour_uri
+        DRb.start_service
+        uri = URI.parse(DRb.uri)
+        uri.path = File.expand_path(".")
+        uri.scheme = "testjour"
+        uri.user = `whoami`.strip
+        uri.to_s
+      end
+    end
+   
+    Parser.register_command Warm
+  end
+end

data/lib/testjour/commands.rb

@@ -0,0 +1,10 @@
+require "testjour/commands/help"
+require "testjour/commands/version"
+require "testjour/commands/run"
+require "testjour/commands/list"
+require "testjour/commands/slave_start"
+require "testjour/commands/slave_stop"
+require "testjour/commands/slave_run"
+require "testjour/commands/slave_warm"
+require "testjour/commands/warm"
+require "testjour/commands/local_run"

data/lib/testjour/cucumber_extensions/drb_formatter.rb

@@ -0,0 +1,30 @@
+module Testjour
+  
+  class DRbFormatter
+  
+    def initialize(queue_server)
+      @queue_server = queue_server
+    end
+    
+    def step_passed(step, regexp, args)
+      @queue_server.write_result DRb.uri, "."
+    end
+  
+    def step_failed(step, regexp, args)
+      @queue_server.write_result DRb.uri, "F", step.error.message, step.error.backtrace
+    end
+  
+    def step_pending(step, regexp, args)
+      @queue_server.write_result DRb.uri, "P"
+    end
+
+    def step_skipped(step, regexp, args)
+      @queue_server.write_result DRb.uri, "_"
+    end
+    
+    def method_missing(*args, &block)
+    end
+    
+  end
+  
+end

data/lib/testjour/cucumber_extensions/queueing_executor.rb

@@ -0,0 +1,120 @@
+require "testjour/colorer"
+require "testjour/progressbar"
+
+module Testjour
+  
+  class QueueingExecutor < ::Cucumber::Tree::TopDownVisitor
+    attr_reader :step_count
+    attr_accessor :formatter
+    
+    class << self
+      attr_accessor :queue
+    end
+
+    def initialize(queue_server, step_mother)
+      @queue_server = queue_server
+      @step_count = 0
+      @passed  = 0
+      @skipped = 0
+      @pending = 0
+      @result_uris = []
+      @errors  = []
+    end
+    
+    def wait_for_results
+      progress_bar = ProgressBar.new("0 slaves", step_count)
+      
+      step_count.times do
+        log_result(*@queue_server.take_result)
+        
+        if failed?
+          progress_bar.colorer = Testjour::Colorer.method(:failed).to_proc
+          progress_bar.title = "#{@result_uris.size} slaves, #{@errors.size} failures"
+        else
+          progress_bar.colorer = Testjour::Colorer.method(:passed).to_proc
+          progress_bar.title   = "#{@result_uris.size} slaves"
+        end
+        
+        progress_bar.inc
+      end
+      
+      progress_bar.finish
+
+      print_summary
+      print_errors
+    end
+    
+    def failed?
+      @errors.any?
+    end
+    
+    
+    def log_result(uri, dot, message, backtrace)
+      @result_uris << uri
+      @result_uris.uniq!
+      
+      case dot
+      when "."
+        @passed += 1
+      when "F"
+        @errors << [message, backtrace]
+      when "P"
+        @pending += 1
+      when "_"
+        @skipped += 1
+      end
+    end
+
+    def print_summary
+      puts
+      puts
+      puts Colorer.passed("#{@passed} steps passed") unless @passed.zero?
+      puts Colorer.failed("#{@errors.size} steps failed") unless @errors.empty?
+      puts Colorer.skipped("#{@skipped} steps skipped") unless @skipped.zero?
+      puts Colorer.pending("#{@pending} steps pending") unless @pending.zero?
+      puts
+    end
+    
+    def print_errors
+      @errors.each_with_index do |error, i|
+        message, backtrace = error
+        
+        puts
+        puts Colorer.failed("#{i+1})")
+        puts Colorer.failed(message)
+        puts Colorer.failed(backtrace)
+      end
+    end
+    
+    def visit_feature(feature)
+      super
+      @queue_server.write_work(feature.file)
+    end
+
+    def visit_row_scenario(scenario)
+      visit_scenario(scenario)
+    end
+    
+    def visit_regular_scenario(scenario)
+      visit_scenario(scenario)
+    end
+    
+    def visit_row_step(step)
+      visit_step(step)
+    end
+    
+    def visit_regular_step(step)
+      visit_step(step)
+    end
+    
+    def visit_step(step)
+      @step_count += 1
+    end
+    
+    def method_missing(*args)
+      # Do nothing
+    end
+
+  end
+  
+end

data/lib/testjour/mysql.rb

@@ -0,0 +1,82 @@
+module Testjour
+  
+  # Stolen from deep-test
+  
+  class MysqlDatabaseSetup
+    class << self
+      #
+      # ActiveRecord configuration to use when connecting to
+      # MySQL to create databases, drop database, and grant
+      # privileges.  By default, connects to information_schema
+      # on localhost as root with no password.
+      #
+      attr_accessor :admin_configuration
+    end
+    
+    self.admin_configuration = {
+      :adapter  => "mysql",
+      :host     => "localhost",
+      :username => "root",
+      :database => "information_schema"
+    }
+
+    def self.with_new_database
+      mysql = self.new
+      mysql.create_database
+      
+      at_exit do
+        mysql.drop_database
+      end
+      
+      mysql.connect
+      mysql.load_schema
+      
+      yield
+    end
+
+    def grant_privileges(connection)
+      sql = %{grant all on #{runner_database_name}.* 
+          to %s@'localhost' identified by %s;} % [
+        connection.quote(self.class.admin_configuration[:username]),
+        connection.quote(self.class.admin_configuration[:password] || "")
+      ]
+      connection.execute sql
+    end
+    
+    def create_database
+      admin_connection do |connection|
+        connection.recreate_database runner_database_name
+        grant_privileges(connection)
+      end
+    end
+    
+    def drop_database
+      admin_connection do |connection|
+        connection.drop_database runner_database_name
+      end
+    end
+
+    def connect
+      ActiveRecord::Base.establish_connection(self.class.admin_configuration.merge(:database => runner_database_name))
+    end
+
+    def load_schema
+      # silence_stream(STDOUT) do
+        load File.join(RAILS_ROOT, "db", "schema.rb")
+      # end
+    end
+
+    def admin_connection
+      conn = ActiveRecord::Base.mysql_connection(self.class.admin_configuration)
+      yield conn
+    ensure
+      conn.disconnect! if conn
+    end
+    
+    def runner_database_name
+      @runner_database_name ||= "testjour_runner_#{rand(1_000)}"
+    end
+  end
+  
+end
+

data/lib/testjour/pid_file.rb

@@ -0,0 +1,43 @@
+module Testjour
+  
+  class PidFile
+    
+    def initialize(path)
+      @path = File.expand_path(path)
+    end
+    
+    def verify_doesnt_exist
+      if File.exist?(@path)
+        puts "!!! PID file #{@path} already exists.  testjour could be running already."
+        puts "!!! Exiting with error.  You must stop testjour and clear the .pid before I'll attempt a start."
+        exit 1
+      end
+    end
+    
+    def send_signal(signal)
+      pid = open(@path).read.to_i
+      print "Sending #{signal} to Testjour at PID #{pid}..."
+      begin
+        Process.kill(signal, pid)
+      rescue Errno::ESRCH
+        puts "Process does not exist.  Not running."
+      end
+
+      puts "Done."
+    end
+    
+    def write
+      open(@path, "w") { |f| f.write(Process.pid) }
+      open(@path, "w") do |f|
+        f.write(Process.pid)
+        File.chmod(0644, @path)
+      end
+    end
+    
+    def remove
+      File.unlink(@path) if @path and File.exists?(@path)
+    end
+    
+  end
+  
+end