testbot_instructure 0.7.8

data/lib/shared/adapters/adapter.rb

@@ -0,0 +1,27 @@
+class Adapter
+
+  FILES = Dir[File.dirname(__FILE__) + "/*_adapter.rb"]
+  FILES.each { |file| require(file) }
+
+  def self.all
+    FILES.map { |file| load_adapter(file) }
+  end
+
+  def self.find(type)
+    if adapter = all.find { |adapter| adapter.type == type.to_s }
+      adapter
+    else
+      raise "Unknown adapter: #{type}"
+    end
+  end
+
+  private
+
+  def self.load_adapter(file)
+    eval("::" + File.basename(file).
+         gsub(/\.rb/, '').
+         gsub(/(?:^|_)(.)/) { $1.upcase })
+  end
+
+end
+

data/lib/shared/adapters/cucumber_adapter.rb

@@ -0,0 +1,91 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/helpers/ruby_env"))
+require File.expand_path(File.join(File.dirname(__FILE__), "../color"))
+
+class CucumberAdapter
+  
+  def self.command(project_path, ruby_interpreter, files)
+    cucumber_command = RubyEnv.ruby_command(project_path, :script => "script/cucumber", :bin => "cucumber",
+                                                          :ruby_interpreter => ruby_interpreter)
+    "export AUTOTEST=1; #{cucumber_command} -f progress --backtrace -r features/support -r features/step_definitions #{files} -t ~@disabled"
+  end
+ 
+  def self.test_files(dir)
+    Dir["#{dir}/#{file_pattern}"]
+  end
+  
+  def self.get_sizes(files)
+    files.map { |file| File.stat(file).size }
+  end
+
+  def self.requester_port
+    2230
+  end
+  
+  def self.pluralized
+    'features'
+  end
+  
+  def self.base_path
+    pluralized
+  end
+  
+  def self.name
+    'Cucumber'
+  end
+  
+  def self.type
+    pluralized
+  end
+
+  # This is an optional method. It gets passed the entire test result and summarizes it. See the tests.
+  def self.sum_results(text)
+    scenarios, steps = parse_scenarios_and_steps(text)
+
+    scenarios_line = "#{scenarios[:total]} scenarios (" + [
+      (Color.colorize("#{scenarios[:failed]} failed", :red) if scenarios[:failed] > 0),
+      (Color.colorize("#{scenarios[:undefined]} undefined", :orange) if scenarios[:undefined] > 0),
+      (Color.colorize("#{scenarios[:passed]} passed", :green) if scenarios[:passed] > 0)
+    ].compact.join(', ') + ")"
+
+    steps_line = "#{steps[:total]} steps (" + [
+      (Color.colorize("#{steps[:failed]} failed", :red) if steps[:failed] > 0),
+      (Color.colorize("#{steps[:skipped]} skipped", :cyan) if steps[:skipped] > 0),
+      (Color.colorize("#{steps[:undefined]} undefined", :orange) if steps[:undefined] > 0),
+      (Color.colorize("#{steps[:passed]} passed", :green) if steps[:passed] > 0)
+    ].compact.join(', ') + ")"
+
+    scenarios_line + "\n" + steps_line
+  end
+
+private
+
+  def self.parse_scenarios_and_steps(text)
+    results = {
+      :scenarios => { :total => 0, :passed => 0, :failed => 0, :undefined => 0 },
+      :steps => { :total => 0, :passed => 0, :failed => 0, :skipped => 0, :undefined => 0 }
+    }
+
+    Color.strip(text).split("\n").each do |line|
+      type = line.include?("scenarios") ? :scenarios : :steps
+        
+      if match = line.match(/\((.+)\)/)
+        results[type][:total] += line.split.first.to_i
+        parse_status_counts(results[type], match[1])
+      end
+    end
+
+    [ results[:scenarios], results[:steps] ]
+  end
+
+  def self.parse_status_counts(results, status_counts)
+    status_counts.split(', ').each do |part|
+      results.keys.each do |key|
+        results[key] += part.split.first.to_i if part.include?(key.to_s)
+      end
+    end
+  end
+
+  def self.file_pattern
+    '**/**/*.feature'
+  end
+end

data/lib/shared/adapters/helpers/ruby_env.rb

@@ -0,0 +1,47 @@
+class RubyEnv
+  def self.bundler?(project_path)
+    gem_exists?("bundler") && File.exists?("#{project_path}/Gemfile")
+  end
+
+  def self.gem_exists?(gem)
+    if Gem::Specification.respond_to?(:find_by_name)
+      Gem::Specification.find_by_name(gem)
+    else
+      # older depricated method
+      Gem.available?(gem)
+    end
+  rescue Gem::LoadError
+    false
+  end
+
+  def self.ruby_command(project_path, opts = {})
+    ruby_interpreter = opts[:ruby_interpreter] || "ruby"
+
+    if opts[:script] && File.exists?("#{project_path}/#{opts[:script]}")
+      command = opts[:script]
+    elsif opts[:bin]
+      command = opts[:bin]
+    else
+      command = nil
+    end
+
+    if bundler?(project_path)
+      "#{rvm_prefix(project_path)} #{ruby_interpreter} -S bundle exec #{command}".strip
+    else
+      "#{rvm_prefix(project_path)} #{ruby_interpreter} -S #{command}".strip
+    end
+  end
+
+  def self.rvm_prefix(project_path)
+    if rvm?
+      rvmrc_path = File.join project_path, ".rvmrc"
+      if File.exists?(rvmrc_path)
+        File.read(rvmrc_path).to_s.strip + " exec"
+      end
+    end
+  end
+
+  def self.rvm?
+    system("rvm info") != nil
+  end
+end

data/lib/shared/adapters/rspec2_adapter.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/helpers/ruby_env"))
+
+class Rspec2Adapter
+
+  def self.command(project_path, ruby_interpreter, files)
+    spec_command = RubyEnv.ruby_command(project_path,
+      :bin => "rspec",
+      :ruby_interpreter => ruby_interpreter)
+
+    if File.exists?("#{project_path}/spec/spec.opts")
+      spec_command += " -O spec/spec.opts"
+    end
+
+    "export RSPEC_COLOR=true; #{spec_command} #{files}"
+  end
+
+  def self.test_files(dir)
+    if ENV['SELENIUM_SPECS']
+      puts 'running selenium specs'
+      test_files = FileList['spec/selenium/**/*_spec.rb'] + FileList['vendor/plugins/*/spec_canvas/selenium/*_spec.rb']
+    elsif ENV['PLUGIN_SPECS']
+      puts 'running plugin specs'
+      test_files = FileList['vendor/plugins/*/spec_canvas/**/*_spec.rb'].exclude('vendor/plugins/*/spec_canvas/selenium/*_spec.rb') + FileList['spec/**/*_spec.rb'].exclude('spec/selenium/**/*_spec.rb')
+    :ew3else
+      puts 'normal pattern'
+      test_files = Dir["#{dir}/#{file_pattern}"]
+    end
+    test_files
+  end
+ 
+  def self.get_sizes(files)
+    files.map { |file| File.stat(file).size }
+  end
+
+  def self.requester_port
+    2299
+  end
+
+  def self.pluralized
+    'specs'
+  end
+
+  def self.base_path
+    "spec"
+  end
+
+  def self.name
+    'RSpec2'
+  end
+
+  def self.type
+    'rspec'
+  end
+
+private
+
+  def self.file_pattern
+    '**/**/*_spec.rb'
+  end
+
+end

data/lib/shared/adapters/rspec_adapter.rb

@@ -0,0 +1,79 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/helpers/ruby_env"))
+require File.expand_path(File.join(File.dirname(__FILE__), "../color"))
+
+class RspecAdapter
+  
+  def self.command(project_path, ruby_interpreter, files)
+    spec_command = RubyEnv.ruby_command(project_path, :script => "script/spec", :bin => "rspec",
+                                                      :ruby_interpreter => ruby_interpreter)
+    if File.exists?("#{project_path}/spec/spec.opts")
+      spec_command += " -O spec/spec.opts"
+    end
+
+    "export RSPEC_COLOR=true; #{spec_command} #{files}"
+  end
+  
+  def self.test_files(dir)
+    Dir["#{dir}/#{file_pattern}"]
+  end
+
+  def self.get_sizes(files)
+    files.map { |file| File.stat(file).size }
+  end
+  
+  def self.requester_port
+    2299
+  end
+  
+  def self.pluralized
+    'specs'
+  end
+  
+  def self.base_path
+    type
+  end
+  
+  def self.name
+    'RSpec'
+  end
+  
+  def self.type
+    'spec'
+  end
+
+  # This is an optional method. It gets passed the entire test result and summarizes it. See the tests.
+  def self.sum_results(results)
+    examples, failures, pending = 0, 0, 0
+    results.split("\n").each do |line|
+      line =~ /(\d+) examples?, (\d+) failures?(, (\d+) pending)?/
+      next unless $1
+      examples += $1.to_i
+      failures += $2.to_i
+      pending += $4.to_i
+    end
+
+    result = [ pluralize(examples, 'example'), pluralize(failures, 'failure'), (pending > 0 ? "#{pending} pending" : nil) ].compact.join(', ')
+    if failures == 0 && pending == 0
+      Color.colorize(result, :green)
+    elsif failures == 0 && pending > 0
+      Color.colorize(result, :orange)
+    else
+      Color.colorize(result, :red)
+    end
+  end
+
+private
+
+  def self.pluralize(count, singular)
+    if count == 1
+      "#{count} #{singular}"
+    else
+      "#{count} #{singular}s"
+    end
+  end
+
+  def self.file_pattern
+    '**/**/*_spec.rb'
+  end
+    
+end

data/lib/shared/adapters/test_unit_adapter.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/helpers/ruby_env"))
+
+class TestUnitAdapter
+  
+  def self.command(project_path, ruby_interpreter, files)
+    ruby_command = RubyEnv.ruby_command(project_path, :ruby_interpreter => ruby_interpreter)
+    %{#{ruby_command} -Itest -e '%w(#{files}).each { |file| require(Dir.pwd + "/" + file) }'}
+  end
+  
+  def self.test_files(dir)
+    Dir["#{dir}/#{file_pattern}"]
+  end
+
+  def self.get_sizes(files)
+    files.map { |file| File.stat(file).size }
+  end
+  
+  def self.requester_port
+    2231
+  end
+  
+  def self.pluralized
+    'tests'
+  end
+  
+  def self.base_path
+    type
+  end
+  
+  def self.name
+    'Test::Unit'
+  end
+  
+  def self.type
+    'test'
+  end  
+  
+private
+
+  def self.file_pattern
+    '**/**/*_test.rb'
+  end
+  
+end

data/lib/shared/color.rb

@@ -0,0 +1,16 @@
+class Color
+  def self.colorize(text, color)
+    colors = { :green => 32, :orange => 33, :red => 31, :cyan => 36 }
+
+    if colors[color]
+      "\033[#{colors[color]}m#{text}\033[0m"
+    else
+      raise "Color not implemented: #{color}"
+    end
+  end
+
+  def self.strip(text)
+    text.gsub(/\e.+?m/, '')
+  end
+end
+

data/lib/shared/simple_daemonize.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'daemons'
+
+class SimpleDaemonize
+  
+  def self.start(proc, pid_path, app_name)    
+    working_dir = Dir.pwd
+
+    group = Daemons::ApplicationGroup.new(app_name)
+    group.new_application(:mode => :none).start
+
+    File.open(pid_path, 'w') { |file| file.write(Process.pid) }
+    Dir.chdir(working_dir)
+    proc.call
+  end
+  
+  def self.stop(pid_path)
+    return unless File.exists?(pid_path)
+    pid = File.read(pid_path)
+
+    system "kill -9 #{pid} &> /dev/null"
+    system "rm #{pid_path} &> /dev/null"
+  end
+  
+end

data/lib/shared/ssh_tunnel.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'net/ssh'
+
+class SSHTunnel
+  
+  def initialize(host, user, local_port = 2288)
+    @host, @user, @local_port = host, user, local_port
+  end
+  
+  def open
+    connect
+    
+    start_time = Time.now
+    while true
+      break if @up
+      sleep 0.5
+      
+      if Time.now - start_time > 5
+        puts "SSH connection failed, trying again..."
+        start_time = Time.now
+        connect
+      end
+    end
+  end
+  
+  def connect
+    @thread.kill! if @thread
+    @thread = Thread.new do
+      Net::SSH.start(@host, @user, { :timeout => 1 }) do |ssh|
+        ssh.forward.local(@local_port, 'localhost', Testbot::SERVER_PORT)
+        ssh.loop {  @up = true }
+      end
+    end    
+  end
+  
+end

data/lib/shared/testbot.rb

@@ -0,0 +1,132 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '/version'))
+require File.expand_path(File.join(File.dirname(__FILE__), '/simple_daemonize'))
+require File.expand_path(File.join(File.dirname(__FILE__), '/adapters/adapter'))
+require 'fileutils'
+
+module Testbot
+  require 'railtie' if defined?(Rails)
+
+  if ENV['INTEGRATION_TEST']
+    SERVER_PID = "/tmp/integration_test_testbot_server.pid"
+    RUNNER_PID = "/tmp/integration_test_testbot_runner.pid"
+  else
+    SERVER_PID = "/tmp/testbot_server.pid"
+    RUNNER_PID = "/tmp/testbot_runner.pid"
+  end
+
+  DEFAULT_WORKING_DIR = "/tmp/testbot"
+  DEFAULT_SERVER_PATH = "/tmp/testbot/#{ENV['USER']}"
+  DEFAULT_USER = "testbot"
+  DEFAULT_PROJECT = "project"
+  DEFAULT_RUNNER_USAGE = "100%"
+  SERVER_PORT = ENV['INTEGRATION_TEST'] ? 22880 : 2288
+
+  class CLI
+
+    def self.run(argv)
+      return false if argv == []
+      opts = parse_args(argv)
+
+      if opts[:help]
+        return false
+      elsif opts[:version]
+        puts "Testbot #{Testbot.version}"
+      elsif [ true, 'run', 'start' ].include?(opts[:server])
+        start_server(opts[:server])
+      elsif opts[:server] == 'stop'
+        stop('server', Testbot::SERVER_PID)
+      elsif [ true, 'run', 'start' ].include?(opts[:runner])
+        require File.expand_path(File.join(File.dirname(__FILE__), '/../runner/runner'))
+        return false unless valid_runner_opts?(opts)
+        start_runner(opts)
+      elsif opts[:runner] == 'stop'
+        stop('runner', Testbot::RUNNER_PID)
+      elsif adapter = Adapter.all.find { |adapter| opts[adapter.type.to_sym] }
+        require File.expand_path(File.join(File.dirname(__FILE__), '/../requester/requester'))
+        start_requester(opts, adapter)
+      end
+
+      true
+    end
+
+    def self.parse_args(argv)
+      last_setter = nil
+      hash = {}
+      str = ''
+      argv.each_with_index do |arg, i|
+        if arg.include?('--')
+          str = ''
+          last_setter = arg.split('--').last.to_sym
+          hash[last_setter] = true if (i == argv.size - 1) || argv[i+1].include?('--')
+        else
+          str += ' ' + arg
+          hash[last_setter] = str.strip
+        end
+      end
+      hash
+    end
+
+    def self.start_runner(opts)
+      stop('runner', Testbot::RUNNER_PID)
+
+      proc = lambda {
+        working_dir = opts[:working_dir] || Testbot::DEFAULT_WORKING_DIR
+        FileUtils.mkdir_p(working_dir)
+        Dir.chdir(working_dir)
+        runner = Runner::Runner.new(:server_host => opts[:connect],
+                                    :auto_update => opts[:auto_update], :max_instances => opts[:cpus],
+                                    :ssh_tunnel => opts[:ssh_tunnel], :server_user => opts[:user],
+                                    :max_jruby_instances => opts[:max_jruby_instances],
+                                    :dev_gem_root => opts[:dev_gem_root],
+                                    :wait_for_updated_gem => opts[:wait_for_updated_gem],
+                                    :jruby_opts => opts[:jruby_opts])
+        runner.run!
+      }
+
+      if opts[:runner] == 'run'
+        proc.call
+      else
+        puts "Testbot runner started (pid: #{Process.pid})"
+        SimpleDaemonize.start(proc, Testbot::RUNNER_PID, "testbot (runner)")
+      end
+    end
+
+    def self.start_server(type)
+      stop('server', Testbot::SERVER_PID)
+      require File.expand_path(File.join(File.dirname(__FILE__), '/../server/server'))
+
+      if type == 'run'
+        Sinatra::Application.run! :environment => "production"
+      else
+        puts "Testbot server started (pid: #{Process.pid})"
+        SimpleDaemonize.start(lambda {
+          Sinatra::Application.run! :environment => "production"
+        }, Testbot::SERVER_PID, "testbot (server)")
+      end
+    end
+
+    def self.stop(name, pid)
+      puts "Testbot #{name} stopped" if SimpleDaemonize.stop(pid)
+    end
+
+    def self.start_requester(opts, adapter)
+      requester = Requester::Requester.new(:server_host            => opts[:connect],
+                                           :rsync_path             => opts[:rsync_path],
+                                           :rsync_ignores          => opts[:rsync_ignores].to_s,
+                                           :available_runner_usage => nil,
+                                           :project                => opts[:project],
+                                           :ssh_tunnel             => opts[:ssh_tunnel], :server_user => opts[:user])
+      requester.run_tests(adapter, adapter.base_path)
+    end
+
+    def self.valid_runner_opts?(opts)
+      opts[:connect].is_a?(String)
+    end
+
+    def self.lib_path
+      File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+    end
+
+  end
+
+end

data/lib/shared/version.rb

@@ -0,0 +1,12 @@
+module Testbot
+  # Don't forget to update readme and changelog
+  def self.version
+    version = "0.7.8"
+    dev_version_file = File.join(File.dirname(__FILE__), '..', '..', 'DEV_VERSION')
+    if File.exists?(dev_version_file)
+      version += File.read(dev_version_file)
+    end
+    version
+  end
+end
+

data/lib/tasks/testbot.rake

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../shared/adapters/adapter'
+
+namespace :testbot do
+  
+  def run_and_show_results(adapter, custom_path)
+    'testbot:before_request'.tap { |t| Rake::Task.task_defined?(t) && Rake::Task[t].invoke }
+        
+    require File.expand_path(File.join(File.dirname(__FILE__), '..', 'requester', 'requester.rb'))
+    requester = Testbot::Requester::Requester.create_by_config("#{Rails.root}/config/testbot.yml")
+
+    puts "Running #{adapter.pluralized}..."
+    start_time = Time.now
+    
+    path = custom_path ? "#{adapter.base_path}/#{custom_path}" : adapter.base_path
+    success = requester.run_tests(adapter, path)
+    
+    puts
+    puts "Finished in #{Time.now - start_time} seconds."
+    success
+  end
+  
+  Adapter.all.each do |adapter|
+
+    desc "Run the #{adapter.name} tests using testbot"
+    task adapter.type, :custom_path do |_, args|
+      exit 1 unless run_and_show_results(adapter, args[:custom_path])
+    end
+    
+  end
+end

data/lib/testbot.rb

@@ -0,0 +1,2 @@
+# Rails plugin hook
+require File.expand_path(File.join(File.dirname(__FILE__), '/shared/testbot'))

data/test/fixtures/local/Rakefile

@@ -0,0 +1,7 @@
+namespace :testbot do
+  
+  task :before_run do
+    puts "prepare got called"
+  end
+  
+end

data/test/fixtures/local/config/testbot.yml

@@ -0,0 +1,5 @@
+server_host: localhost
+rsync_path: ../server
+available_runner_usage: 100%
+rsync_ignores: log/* tmp/*
+

data/test/fixtures/local/script/spec

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+puts "script/spec got called with #{ARGV.inspect}"