brynary-testjour 0.1.0

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2008-09-23
+
+* 1 major enhancement
+
+  * Birthday!
+

data/MIT-LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Bryan Helmkamp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,47 @@
+=== Testjour
+
+* http://github.com/brynary/testjour
+
+=== Description
+
+Distributed test running with autodiscovery via Bonjour (for Cucumber first)
+
+=== Synopsis
+
+On machines to be used as Testjour slaves:
+
+    $ mkdir testjour-working-dir
+    $ testjour slave:start
+
+    
+On your development machine, verify it can see the testjour slave:
+
+    $ testjour list
+    
+    Testjour servers:
+
+        bhelmkamp    available    bryans-computer.local.:62434
+        
+Now run your tests:
+    
+    $ testjour run features
+
+Note: This only really makes sense if you use more than one slave. Otherwise
+it's slower than just running them locally.
+
+=== Install
+
+To install the latest release (once there is a release):
+
+    $ sudo gem install testjour
+    
+For now, just pull down the code from the GitHub repo:
+    
+    $ git clone git://github.com/brynary/testjour.git
+    $ cd testjour
+    $ rake gem
+    $ rake install_gem
+
+=== Authors
+
+- Maintained by Bryan Helmkamp (http://brynary.com/)

data/Rakefile

@@ -0,0 +1,39 @@
+require 'rubygems'
+require "rake/gempackagetask"
+require "rake/clean"
+require './lib/testjour.rb'
+
+spec = Gem::Specification.new do |s|
+  s.name         = "testjour"
+  s.version      = Testjour::VERSION
+  s.author       = "Bryan Helmkamp"
+  s.email        = "bryan" + "@" + "brynary.com"
+  s.homepage     = "http://github.com/brynary/testjour"
+  s.summary      = "Distributed test running with autodiscovery via Bonjour (for Cucumber first)"
+  s.description  = s.summary
+  s.executables  = "testjour"
+  s.files        = %w[History.txt MIT-LICENSE.txt README.rdoc Rakefile] + Dir["bin/*"] + Dir["lib/**/*"] + Dir["vendor/**/*"]
+  
+  s.add_dependency "systemu", ">=1.2.0"
+  s.add_dependency "dnssd", ">=0.6.0"
+end
+
+Rake::GemPackageTask.new(spec) do |package|
+  package.gem_spec = spec
+end
+
+desc 'Show information about the gem.'
+task :write_gemspec do
+  File.open("testjour.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+  puts "Generated: testjour.gemspec"
+end
+
+CLEAN.include ["pkg", "*.gem", "doc", "ri", "coverage"]
+
+desc 'Install the package as a gem.'
+task :install_gem => [:clean, :package] do
+  gem = Dir['pkg/*.gem'].first
+  sh "sudo gem install --local #{gem}"
+end

data/bin/testjour

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/testjour")
+
+require "testjour/cli"
+require "testjour/commands"
+
+Testjour::CLI.execute

data/lib/testjour/bonjour.rb

@@ -0,0 +1,56 @@
+require "dnssd"
+require "set"
+
+Thread.abort_on_exception = true
+
+module Testjour
+  SERVICE = "_testjour._tcp"  
+  
+  class Bonjour
+    
+    class Server
+      attr_reader :name, :host, :port
+      
+      def initialize(name, host, port)
+        @name = name
+        @host = host
+        @port = port
+      end
+      
+      def ==(other)
+        other.class == self.class && other.uri == self.uri
+      end
+      
+      def uri
+        "druby://" + @host.gsub(/\.$/, "") + ":" + @port.to_s
+      end
+    end
+    
+    def self.list
+      hosts = []
+
+      service = DNSSD.browse(SERVICE) do |reply|
+        DNSSD.resolve(reply.name, reply.type, reply.domain) do |rr|
+          server = Server.new(reply.name, rr.target, rr.port)
+          hosts << server unless hosts.any? { |h| h == server }
+        end
+      end
+
+      sleep 3
+      service.stop
+      return hosts
+    end
+    
+    def self.serve(port)
+      name = ENV['USER']
+
+      tr = DNSSD::TextRecord.new
+      tr['description'] = "#{name}'s testjour server"
+
+      DNSSD.register(name, SERVICE, "local", port, tr.encode) do |reply|
+        Testjour.logger.info "Broadcasting: Ready to run tests under name '#{name}' on port #{port}..."
+      end
+    end
+  end
+  
+end

data/lib/testjour/cli.rb

@@ -0,0 +1,78 @@
+module Testjour
+  module CLI
+
+    class NoCommandGiven < StandardError
+      def message
+        "No command given"
+      end
+    end
+
+    class UnknownCommand < StandardError
+      def initialize(command_name)
+        @command_name = command_name
+      end
+
+      def message
+        "Unknown command: #{@command_name.inspect}"
+      end
+    end
+
+    def self.execute
+      Parser.new.execute
+    end
+    
+    class Parser
+      class << self
+        attr_accessor :commands
+        
+        def register_command(klass)
+          @commands << klass
+        end
+      end
+      
+      self.commands = []
+
+      def execute
+        begin
+          raise NoCommandGiven if ARGV.empty?
+          raise UnknownCommand.new(command_name) unless command_klass
+          
+          args = ARGV.dup
+          args.shift # Remove subcommand name
+          
+          command_klass.new(self, args).run
+        rescue NoCommandGiven, UnknownCommand
+          $stderr.puts "ERROR: #{$!.message}"
+          $stderr.puts usage
+          exit 1
+        end
+      end
+      
+      def command_klass
+        self.class.commands.detect do |command_klass|
+          command_klass.command == command_name
+        end
+      end
+
+      def command_name
+        ARGV.first
+      end
+      
+      def usage
+        message = []
+        message << "usage: testjour <SUBCOMMAND> [OPTIONS] [ARGS...]"
+        message << "Type 'testjour help <SUBCOMMAND>' for help on a specific subcommand."
+        message << "Type 'testjour version' to get this program's version."
+        message << ""
+        message << "Available subcommands are:"
+        
+        self.class.commands.sort_by { |c| c.command }.each do |command_klass|
+          message << "  " + command_klass.command
+        end
+        
+        message.map { |line| line.chomp }.join("\n")
+      end
+    end
+    
+  end
+end

data/lib/testjour/colorer.rb

@@ -0,0 +1,8 @@
+require "cucumber"
+require "cucumber/formatters/ansicolor"
+
+module Testjour
+  class Colorer
+    extend ::Cucumber::Formatters::ANSIColor
+  end
+end

data/lib/testjour/commands/base_command.rb

@@ -0,0 +1,53 @@
+require "optparse"
+
+module Testjour
+  module CLI
+
+    class BaseCommand
+      attr_reader :non_options, :options
+
+      def self.command
+        self.name.downcase
+      end
+      
+      def self.options
+        {}
+      end
+  
+      def self.help
+        nil
+      end
+  
+      def self.detailed_help
+        nil
+      end
+      
+      # def self.usage
+      #   message = []
+      #   
+      #   if help.nil?
+      #     message << command
+      #   else
+      #     message << "#{command}: #{help}"
+      #   end
+      #   message << detailed_help unless detailed_help.nil?
+      #   message << ""
+      #   message << "Valid options:"
+      #   message
+      #   @option_parser.summarize(message)
+      # end
+        
+      def initialize(parser, args)
+        @parser   = parser
+        @options  = {}
+        @non_options = option_parser.parse(args)
+      end
+      
+      def option_parser
+        OptionParser.new
+      end
+      
+    end
+    
+  end
+end

data/lib/testjour/commands/help.rb

@@ -0,0 +1,20 @@
+require "testjour/commands/base_command"
+
+module Testjour
+  module CLI
+    
+    class HelpCommand < BaseCommand
+      def self.command
+        "help"
+      end
+      
+      def run
+        puts @parser.usage
+        exit 1
+      end
+    end
+
+    Parser.register_command HelpCommand
+  end
+end
+

data/lib/testjour/commands/list.rb

@@ -0,0 +1,57 @@
+require "drb"
+require "testjour/commands/base_command"
+require "testjour/bonjour"
+
+module Testjour
+  module CLI
+    
+    class List < BaseCommand
+      def self.command
+        "list"
+      end
+      
+      def initialize(*args)
+        super
+        Testjour.load_cucumber
+        require "testjour/colorer"
+      rescue LoadError
+        # No cucumber, we can't use color :(
+      end
+      
+      def run
+        available_servers = Testjour::Bonjour.list
+        
+        if available_servers.any?
+          puts
+          puts "Testjour servers:"
+          puts
+          
+          available_servers.each do |server|
+            slave_server = DRbObject.new(nil, server.uri)
+            status = colorize_status(slave_server.status)
+            puts "    %-12s %s %s" % [server.name, status, "#{server.host}:#{server.port}"]
+          end
+        else
+          puts
+          puts "No testjour servers found."
+        end
+      end
+      
+      def colorize_status(status)
+        formatted_status = ("%-12s" % status)
+        return formatted_status unless defined?(Testjour::Colorer)
+        
+        case formatted_status.strip
+        when "available"
+          Testjour::Colorer.green(formatted_status)
+        else
+          Testjour::Colorer.yellow(formatted_status)
+        end
+      end
+      
+    end
+    
+    Parser.register_command List
+  end
+end
+

data/lib/testjour/commands/local_run.rb

@@ -0,0 +1,83 @@
+require "drb"
+require "uri"
+
+require "testjour/commands/base_command"
+require "testjour/queue_server"
+require "testjour/cucumber_extensions/drb_formatter"
+require "testjour/mysql"
+
+module Testjour
+  module CLI
+  
+    class LocalRun < BaseCommand
+      def self.command
+        "local:run"
+      end
+      
+      def initialize(parser, args)
+        Testjour.logger.debug "Runner command #{self.class}..."
+        super
+        @queue = @non_options.shift
+      end
+  
+      def run
+        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 LocalRun
+  end
+end

data/lib/testjour/commands/run.rb

@@ -0,0 +1,165 @@
+require "drb"
+
+require "testjour/commands/base_command"
+require "testjour/queue_server"
+require "testjour/bonjour"
+
+module Testjour
+  module CLI
+    
+    class Run < BaseCommand
+      def self.command
+        "run"
+      end
+      
+      def initialize(*args)
+        Testjour.logger.debug "Runner command #{self.class}..."
+        Testjour.load_cucumber
+        
+        super
+        @found_server = 0
+        require "testjour/cucumber_extensions/queueing_executor"
+        require "testjour/colorer"
+      end
+      
+      def run
+        Testjour::QueueServer.with_server do |queue|
+          start_local_runners unless servers_specified?
+          start_slave_runners unless no_remote?
+          
+          if @found_server.zero?
+            puts "No processes to build on. Aborting."
+            exit
+          end
+          
+          queue_features(queue)
+          print_results
+        end
+      end
+      
+      def disable_cucumber_require
+        Cucumber::CLI.class_eval do
+          def require_files
+            ARGV.clear # Shut up RSpec
+          end
+        end
+      end
+      
+      def queue_features(queue)
+        Testjour.logger.debug "Queueing features..."
+        disable_cucumber_require
+        ARGV.replace(@non_options.clone)
+        Cucumber::CLI.executor = Testjour::QueueingExecutor.new(queue, Cucumber::CLI.step_mother)
+        Cucumber::CLI.execute
+      end
+      
+      def print_results
+        puts
+        puts "Requesting build from #{@found_server} processes..."
+        puts
+  
+        Cucumber::CLI.executor.wait_for_results
+        Testjour.logger.debug "DONE"
+      end
+      
+      def slave_servers_to_use
+        # require "rubygems"; require "ruby-debug"; Debugger.start; debugger
+        @slave_servers_to_use ||= available_servers.select do |potential_server|
+          !servers_specified? || specified_servers_include?(potential_server)
+        end
+      end
+      
+      def available_servers
+        @available_servers ||= Testjour::Bonjour.list
+      end
+      
+      def request_build_from(server)
+        slave_server = DRbObject.new(nil, server.uri)
+        result = slave_server.run(testjour_uri, @non_options)
+  
+        if result
+          Testjour.logger.info "Requesting buld from available server: #{server.uri}. Accepted."
+          @found_server += 1
+        else
+          Testjour.logger.info "Requesting buld from available server: #{server.uri}. Rejected."
+        end
+      end
+      
+      def start_local_runners
+        2.times do 
+          start_local_runner
+        end
+      end
+      
+      def start_slave_runners
+        slave_servers_to_use.each do |server|
+          request_build_from(server)
+        end
+      end
+      
+      def start_local_runner
+        pid_queue = Queue.new
+
+        Thread.new do
+          Thread.current.abort_on_exception = true
+          cmd = command_for_local_run
+          Testjour.logger.debug "Starting local:run with command: #{cmd}"
+          status, stdout, stderr = systemu(cmd) { |pid| pid_queue << pid }
+          Testjour.logger.warn stderr if stderr.strip.size > 0
+        end
+
+        pid = pid_queue.pop
+        
+        @found_server += 1
+        Testjour.logger.info "Started local:run on PID #{pid}"
+        
+        pid
+      end
+      
+      def command_for_local_run
+        "#{testjour_bin_path} local:run #{testjour_uri} -- #{@non_options.join(' ')}".strip
+      end
+
+      def testjour_bin_path
+        File.expand_path(File.dirname(__FILE__) + "/../../../bin/testjour")
+      end
+      
+      def testjour_uri
+        uri = URI.parse(DRb.uri)
+        uri.path = File.expand_path(".")
+        uri.scheme = "testjour"
+        uri.user = `whoami`.strip
+        uri.to_s
+      end
+      
+      def specified_servers_include?(potential_server)
+        @options[:server].any? do |specified_server|
+          potential_server.host.include?(specified_server)
+        end
+      end
+      
+      def no_remote?
+        @options[:no_remote]
+      end
+      
+      def servers_specified?
+        @options[:server] && @options[:server].any?
+      end
+      
+      def option_parser
+        OptionParser.new do |opts|
+          opts.on("--on SERVER", "Specify a pattern to exclude servers to. Disabled local runners") do |server|
+            @options[:server] ||= []
+            @options[:server] << server
+          end
+          
+          opts.on("--no-remote", "Only use local runners") do |server|
+            @options[:no_remote] = true
+          end
+        end
+      end
+    end
+   
+    Parser.register_command Run
+  end
+end