jstd-runner 0.0.2

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in qa-jtd-runner.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2010 FINN.no AS
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.rdoc

@@ -0,0 +1,25 @@
+= jstd-runner
+
+A gem that provides a tool to launch a JsTestDriver server, capture browser(s) and monitor the involved processes.
+
+= TODO
+
+* Config file
+* Support launching multiple browsers
+* Support launching browser through a remote WebDriver server
+* Configurable logging
+* Prettier logging
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 FINN.no. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/bin/jstd-runner

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "jstd-runner"
+
+JstdRunner::CLI.new(ARGV).run

data/jstd-runner.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "jstd-runner/version"
+
+Gem::Specification.new do |s|
+  s.name        = "jstd-runner"
+  s.version     = JstdRunner::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jari Bakken"]
+  s.email       = ["jari.bakken@gmail.com"]
+  s.homepage    = "http://github.com/jarib/jstd-runner"
+  s.summary     = %q{JsTestDriver wrapper}
+  s.description = %q{Runs a JsTestDriver server + browsers with some built-in monitoring}
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+
+  s.add_dependency "selenium-webdriver", "0.1.0"
+  s.add_dependency "eventmachine", "0.12.10"
+  s.add_dependency "mail", "2.2.10"
+  s.add_dependency "daemons", "1.1.0"
+
+  s.add_development_dependency "rspec", ">= 2.0.0"
+end

data/lib/jstd-runner.rb

@@ -0,0 +1,27 @@
+require "logger"
+require "optparse"
+require "etc"
+
+module JstdRunner
+  Log = Logger.new(STDOUT)
+
+  class << self
+    attr_accessor :shutting_down
+  end
+end
+
+require "selenium-webdriver"
+require "eventmachine"
+require "daemons"
+require "socket"
+require "mail"
+require "fileutils"
+
+require "jstd-runner/cli"
+require "jstd-runner/monitorable"
+require "jstd-runner/browser"
+require "jstd-runner/vnc_control"
+require "jstd-runner/server"
+require "jstd-runner/runner"
+
+

data/lib/jstd-runner/browser.rb

@@ -0,0 +1,62 @@
+module JstdRunner
+  class Browser
+    include Monitorable
+
+    def initialize(type = :firefox)
+      @type     = type
+      @switched = @restarting = false
+    end
+
+    def start
+      Log.info "starting browser - #{@type}"
+      @browser = Selenium::WebDriver.for @type
+    end
+
+    def capture(host, port)
+      @restarting = true
+      @switched = false
+      start unless @browser
+      @browser.get "http://#{host}:#{port}/capture"
+      @restarting = false
+    end
+
+    def restart
+      @restarting = true
+      Log.info "restarting browser - #{@type}"
+      stop rescue nil
+      @switched = false
+      start
+      @restarting = false
+    end
+
+    def stop
+      Log.info "stopping browser - #{@type}"
+      @browser.quit if @browser
+    rescue Errno::ECONNREFUSED
+      # looks like we're not running
+    end
+
+    def running?
+      Log.info "browser state: #{status}"
+      true
+    rescue
+      false
+    end
+
+    def status
+      status_span.text
+    end
+
+    private
+
+    def status_span
+      unless @switched
+        @browser.switch_to.frame("0")
+        @switched = true
+      end
+
+      @browser.find_element(:tag_name => "span")
+    end
+
+  end
+end

data/lib/jstd-runner/cli.rb

@@ -0,0 +1,50 @@
+module JstdRunner
+  class CLI
+
+    def initialize(args)
+      parse args
+    end
+
+    def run
+      runner.run
+    end
+
+    private
+
+    def parse(args)
+      OptionParser.new { |op|
+        op.banner = "Usage: #{File.basename $PROGRAM_NAME} [options]"
+        op.separator ""
+
+        op.on("-p", "--port PORT", Integer) do |port|
+          runner.options[:port] = port
+        end
+
+        op.on("-x", "--vnc") do
+          runner.options[:vnc] = true
+        end
+
+        op.on("-m", "--monitor INTERVAL", Integer) do |int|
+          runner.options[:monitor_interval] = int
+        end
+
+        op.on("-b", "--browser BROWSER", String) do |browser|
+          runner.options[:browser] = browser.to_sym
+        end
+
+        op.on("-d", "--daemonize LOGFILE", String) do |log|
+          runner.options[:daemonize] = log
+        end
+
+        op.on("-n", "--notify email1,email2,email3", Array) do |emails|
+          runner.options[:emails] = emails
+        end
+      }.parse!(args)
+    end
+
+    def runner
+      @runner ||= Runner.new
+    end
+
+  end
+end

data/lib/jstd-runner/monitorable.rb

@@ -0,0 +1,15 @@
+module JstdRunner
+  module Monitorable
+    def monitor(interval, &failure_callback)
+      EM.add_periodic_timer(interval) {
+        next if JstdRunner.shutting_down || @restarting
+        if running?
+          Log.info "ok: #{self}"
+        else
+          Log.info "dead: #{self}"
+          failure_callback.call
+        end
+      }
+    end
+  end
+end

data/lib/jstd-runner/runner.rb

@@ -0,0 +1,167 @@
+module JstdRunner
+  class Runner
+
+    DEFAULT_OPTIONS = {
+      :port             => 4224,
+      :vnc              => false,
+      :monitor_interval => 10,
+      :browser          => :firefox,
+      :daemonize        => false
+    }
+
+    attr_reader :options
+
+    def initialize
+      @options = DEFAULT_OPTIONS.dup
+      @shutting_down = @clean_shutdown = false
+      @server_restarting = @browser_restarting = false
+    end
+
+    def run
+      EM.run {
+        configure_mailer
+        trap_signals
+        daemonize if options[:daemonize]
+        shutdown_hook
+        start_server
+        start_browser
+        capture_browser
+      }
+    end
+
+    private
+
+    def trap_signals
+      trap_signal "INT"
+      trap_signal "TERM"
+    end
+
+    def trap_signal(sig)
+      trap(sig) {
+        trap sig, "DEFAULT"
+        Log.info "received #{sig}, shutting down"
+        stop
+      }
+    end
+
+    def shutting_down?
+      @shutting_down
+    end
+
+    def server_restarting?
+      @server_restarting
+    end
+
+    def browser_restarting?
+      @browser_restarting
+    end
+
+    def clean_shutdown?
+      @clean_shutdown
+    end
+
+    def shutdown_hook
+      at_exit {
+        unless clean_shutdown?
+          body = $! ? [$!.message, $!.backtrace].flatten.join("\n") : '(empty)'
+          notify "exiting @ #{Time.now}", body
+        end
+      }
+    end
+
+    def stop
+      JstdRunner.shutting_down = true
+
+      stop_browser
+      stop_server
+
+      EM.stop
+
+      @clean_shutdown = true
+    end
+
+    def start_server
+      server.start
+      server.monitor(options[:monitor_interval]) {
+        server.restart
+        capture_browser
+      }
+    end
+
+    def stop_server
+      server.stop
+    end
+
+    def start_browser
+      start_vnc if options[:vnc]
+      browser.start
+      browser.monitor(options[:monitor_interval]) {
+        browser.restart
+        capture_browser
+      }
+    end
+
+    def capture_browser
+      Log.info "capturing #{browser.inspect}"
+      browser.capture(server.host, server.port)
+    end
+
+    def stop_browser
+      stop_vnc if options[:vnc]
+      browser.stop
+    end
+
+    def start_vnc
+      vnc.start
+      ENV['DISPLAY'] = vnc.display
+    end
+
+    def stop_vnc
+      vnc.stop
+    end
+
+    def daemonize
+      log_file = options[:daemonize]
+      FileUtils.touch log_file
+
+      Daemonize.daemonize(log_file, "#{$PROGRAM_NAME}-daemonized")
+    end
+
+    def server
+      @server ||= Server.new(options[:port])
+    end
+
+    def browser
+      @browser ||= Browser.new(options[:browser])
+    end
+
+    def vnc
+      @vnc ||= VncControl.new
+    end
+
+    def configure_mailer
+      return unless options[:smtp]
+
+      uri = URI.parse(options[:smtp])
+      Mail.defaults {
+        delivery_method(uri.scheme.to_sym, :address => uri.host, :port => uri.port)
+      }
+    end
+
+    def notify(subject, body)
+      return unless recipients = options[:emails]
+
+      Mail.deliver {
+        from    [Etc.getlogin, Socket.gethostname].join("@")
+        to      recipients
+        subject "JstdRunner @ #{Socket.gethostname}: #{subject}"
+        body    body
+      }
+    end
+
+    def monitor(&blk)
+      EM.add_periodic_timer(@options[:monitor_interval], &blk)
+    end
+
+  end # Runner
+end # JstdRunner

data/lib/jstd-runner/server.rb

@@ -0,0 +1,79 @@
+module JstdRunner
+  class Server
+    include Monitorable
+
+    class StartupError < StandardError
+    end
+
+    class StopError < StandardError
+    end
+
+    JAR            = File.expand_path("../JsTestDriver-1.2.2.jar", __FILE__)
+    LAUNCH_TIMEOUT = 120 # this is huge, but I've seen it happen
+
+    attr_reader :host, :port
+
+    def initialize(port)
+      @host       = "127.0.0.1"
+      @port       = Integer(port)
+      @restarting = false
+    end
+
+    def start
+      Log.info "starting JsTestDriver"
+
+      if immediate_poller.connected?
+        raise StartupError, "JsTestDriver already running on #{@host}:#{@port}"
+      end
+
+      process.start
+
+      unless long_poller.connected?
+        process.stop rescue nil
+        raise StartupError, "could not launch JsTestDriver server on #{@host}:#{@port} within #{LAUNCH_TIMEOUT} seconds"
+      end
+    end
+
+    def restart
+      @restarting = true
+      Log.info "restaring server"
+      stop rescue nil
+      @process = nil
+      start
+      @restarting = false
+    end
+
+    def stop
+      Log.info "stopping JsTestDriver"
+      process.stop
+
+      unless long_poller.closed?
+        raise StopError, "could not stop JsTestDriver server on port #{@host}:#{@port} witin #{LAUNCH_TIMEOUT} seconds"
+      end
+    end
+
+    def running?
+      process.alive? && immediate_poller.connected?
+    end
+
+    private
+
+    def process
+      @process ||= (
+        proc = ChildProcess.new("java", "-jar", JAR, "--port", @port.to_s)
+        proc.io.inherit! if $DEBUG
+
+        proc
+      )
+    end
+
+    def long_poller
+      @long_poller ||= Selenium::WebDriver::SocketPoller.new(@host, @port, LAUNCH_TIMEOUT)
+    end
+
+    def immediate_poller
+      @immediate_poller ||= Selenium::WebDriver::SocketPoller.new(@host, @port, 5)
+    end
+
+  end
+end

data/lib/jstd-runner/version.rb

@@ -0,0 +1,3 @@
+module JstdRunner
+  VERSION = "0.0.2"
+end

data/lib/jstd-runner/vnc_control.rb

@@ -0,0 +1,54 @@
+module JstdRunner
+  class VncControl
+
+    class Error < StandardError
+    end
+
+    class << self
+      def displays
+        Dir[File.expand_path("~/.vnc/*.pid")].map { |e| e[/(\d+)\.pid/, 1] }.compact
+      end
+
+      def all
+        displays.map { |display| new(":#{display}") }
+      end
+    end
+
+    attr_reader :display
+
+    def initialize(display = nil)
+      @display = display
+    end
+
+    def start
+      if @display
+        server @display
+        Log.info "vnc server launched on #{@display.inspect}"
+      else
+        output = server
+        @display = output[/desktop is #{host}(\S+)/, 1]
+      end
+    end
+
+    def stop
+      server "-kill", @display.to_s
+    end
+
+    private
+
+    def server(*args)
+      out = `tightvncserver #{args.join ' '} 2>&1`
+
+      unless $?.success?
+        raise Error, "could not run tightvncserver: #{out.inspect}"
+      end
+
+      out
+    end
+
+    def host
+      @host ||= Socket.gethostname
+    end
+
+  end
+end

data/spec/jstd-runner/browser_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+module JstdRunner
+  describe Browser do
+    let(:browser) { Browser.new }
+
+    it "launches the the browser" do
+      Selenium::WebDriver.should_receive(:for).once
+
+      browser.start
+    end
+
+    it "captures the browser" do
+      mock_driver = mock(Selenium::WebDriver::Driver)
+
+      Selenium::WebDriver.should_receive(:for).and_return(mock_driver)
+      mock_driver.should_receive(:get).with("http://localhost:4224/capture")
+
+      browser.capture "localhost", 4224
+    end
+
+    it "stops the browser" do
+      mock_driver = mock(Selenium::WebDriver::Driver)
+
+      Selenium::WebDriver.should_receive(:for).and_return(mock_driver)
+      mock_driver.should_receive(:quit)
+
+      browser.start
+      browser.stop
+    end
+
+    it "restarts the browser" do
+      browser.should_receive(:stop).once
+      browser.should_receive(:start).once
+
+      browser.restart
+    end
+
+    it "restarts the browser if it was already stopped" do
+      browser.should_receive(:stop).once.and_raise("foo")
+      browser.should_receive(:start).once
+
+      browser.restart
+    end
+
+    it "knows if the browser is running" do
+      browser.stub!(:status_span).and_return(mock(:text => "Waiting..."))
+      browser.should be_running
+    end
+
+    it "knows if the browser is not running" do
+      # if we can't get the span, we assume it's dead
+      browser.stub!(:status_span).and_raise(Errno::ECONNREFUSED)
+      browser.should_not be_running
+    end
+  end
+end

data/spec/jstd-runner/cli_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+module JstdRunner
+  describe CLI do
+    let(:runner) { mock(Runner, :options => {}) }
+    before { Runner.stub!(:new).and_return(runner) }
+
+    def cli(str = '')
+      CLI.new(str.split(" "))
+    end
+
+    it "configures the port" do
+      cli "--port 1234"
+      runner.options[:port].should == 1234
+    end
+
+    it "configures VNC" do
+      cli "--vnc"
+      runner.options[:vnc].should be_true
+    end
+
+    it "configures the monitoring interval" do
+      cli "--monitor 10"
+      runner.options[:monitor_interval].should == 10
+    end
+
+    it "configures the browser type" do
+      cli "--browser chrome"
+      runner.options[:browser].should == :chrome
+    end
+
+    it "configures daemonization" do
+      cli "--daemonize /foo/bar"
+      runner.options[:daemonize].should == "/foo/bar"
+    end
+
+    it "configures email notifications" do
+      cli "--notify a@b.com,x@y.com"
+      runner.options[:emails].should == %w[a@b.com x@y.com]
+    end
+
+    it "delegates to the runner when run" do
+      runner.should_receive(:run)
+      cli.run
+    end
+  end
+end

data/spec/jstd-runner/monitorable_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+module JstdRunner
+  describe Monitorable do
+    let(:object) {
+      obj = Object.new
+
+      class << obj
+        attr_accessor :restarting, :running
+        include Monitorable
+
+        def running?
+          @running
+        end
+      end
+
+      obj
+    }
+
+    before { EM.should_receive(:add_periodic_timer).and_yield }
+    after { JstdRunner.shutting_down = false }
+
+    it "yields if self is not running" do
+      did_yield = false
+
+      object.running = false
+      object.monitor(1) { did_yield = true }
+
+      did_yield.should be_true
+    end
+
+    it "does not yield when self is running" do
+      did_yield = false
+
+      object.running = true
+      object.monitor(1) { did_yield = true }
+
+      did_yield.should be_false
+    end
+
+    it "does not check when we're shutting down" do
+      JstdRunner.shutting_down = true
+      object.should_not_receive :running?
+
+      object.monitor(1) {}
+    end
+
+    it "does not check when self is restarting" do
+      object.restarting = true
+      object.should_not_receive :running?
+
+      object.monitor(1) {}
+    end
+
+  end
+end

data/spec/jstd-runner/runner_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+module JstdRunner
+  describe Runner do
+    let(:runner) { Runner.new }
+
+    before {
+      EM.stub!(:run).and_yield
+      runner.stub!(:at_exit)
+      runner.stub!(:trap)
+    }
+
+    it "runs and watches the server" do
+      browser = mock(Browser).as_null_object
+      runner.stub!(:browser).and_return(browser)
+
+      server = mock(Server, :host => "localhost", :port => 4224)
+      Server.should_receive(:new).with(4224).and_return(server)
+      server.should_receive(:start)
+      server.should_receive(:monitor).with(10)
+
+      runner.run
+    end
+
+    it "runs, captures and watches the browser" do
+      server = mock(Server, :host => "localhost", :port => 1234).as_null_object
+      runner.stub!(:server).and_return(server)
+
+      browser = mock(Browser)
+      Browser.should_receive(:new).with(:firefox).and_return(browser)
+      browser.should_receive(:start)
+      browser.should_receive(:capture).with("localhost", 1234)
+      browser.should_receive(:monitor).with(10)
+
+      runner.run
+    end
+
+    # TODO: more specs here
+  end
+end

data/spec/jstd-runner/server_spec.rb

@@ -0,0 +1,94 @@
+require "spec_helper"
+
+module JstdRunner
+  describe Server do
+
+    let(:server) { Server.new(4224) }
+    let(:mock_process) { mock(ChildProcess, :start => true) }
+    let(:connected_poller) { mock(:connected? => true, :closed? => false) }
+    let(:closed_poller) {  mock(:connected? => false, :closed? => true) }
+
+    it "launches the server on the given port" do
+      server.stub!(:immediate_poller => closed_poller)
+
+      ChildProcess.should_receive(:new).with(
+        "java", "-jar", /JsTestDriver.+\.jar/, "--port", "4224"
+      ).and_return(mock_process)
+
+      server.stub!(:long_poller).and_return(connected_poller)
+
+      server.start
+    end
+
+    it "raises a StartupError if the server is already running" do
+      server.stub!(:immediate_poller => connected_poller)
+      server.stub!(:process => mock_process)
+
+      lambda { server.start }.should raise_error(Server::StartupError)
+    end
+
+    it "raises a StartupError if the server doesn't start" do
+      server.stub!(:immediate_poller => closed_poller)
+      server.stub!(:long_poller => closed_poller)
+      server.stub!(:process => mock_process)
+
+      # in case it's alive but not launched properly
+      mock_process.should_receive(:stop)
+
+      lambda { server.start }.should raise_error(Server::StartupError)
+    end
+
+    it "restarts the server" do
+      server.should_receive(:stop).once
+      server.should_receive(:start).once
+
+      server.restart
+    end
+
+    it "restarts the server even if stop fails" do
+      server.should_receive(:stop).and_raise("argh")
+      server.should_receive(:start).once
+
+      server.restart
+    end
+
+    it "stops the server" do
+      server.stub!(:process => mock_process)
+      server.stub!(:long_poller => mock(:closed? => true))
+
+      mock_process.should_receive(:stop)
+
+      server.stop
+    end
+
+    it "raises a StopError if the server could not be stopped" do
+      server.stub!(:process => mock_process)
+      server.stub!(:long_poller => connected_poller)
+
+      mock_process.should_receive(:stop)
+
+      lambda { server.stop }.should raise_error(Server::StopError)
+    end
+
+    it "knows if the server is alive" do
+      server.stub!(:process => mock(:alive? => true))
+      server.stub!(:immediate_poller => connected_poller)
+
+      server.should be_running
+    end
+
+    it "considers the server dead if it does not respond to connections" do
+      server.stub!(:process => mock(:alive? => true))
+      server.stub!(:immediate_poller => closed_poller)
+
+      server.should_not be_running
+    end
+
+    it "considers the server dead if the process died" do
+      server.stub!(:process => mock(:alive? => false))
+
+      server.should_not be_running
+    end
+
+  end
+end

data/spec/jstd-runner/vnc_control_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+module JstdRunner
+  describe VncControl do
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require "jstd-runner"
+
+JstdRunner::Log.level = Logger::Severity::FATAL

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification 
+name: jstd-runner
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Jari Bakken
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-26 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: selenium-webdriver
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 0
+        version: 0.1.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 12
+        - 10
+        version: 0.12.10
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mail
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 2
+        - 10
+        version: 2.2.10
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: daemons
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :development
+  version_requirements: *id005
+description: Runs a JsTestDriver server + browsers with some built-in monitoring
+email: 
+- jari.bakken@gmail.com
+executables: 
+- jstd-runner
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- autotest/discover.rb
+- bin/jstd-runner
+- jstd-runner.gemspec
+- lib/jstd-runner.rb
+- lib/jstd-runner/JsTestDriver-1.2.2.jar
+- lib/jstd-runner/browser.rb
+- lib/jstd-runner/cli.rb
+- lib/jstd-runner/monitorable.rb
+- lib/jstd-runner/runner.rb
+- lib/jstd-runner/server.rb
+- lib/jstd-runner/version.rb
+- lib/jstd-runner/vnc_control.rb
+- spec/jstd-runner/browser_spec.rb
+- spec/jstd-runner/cli_spec.rb
+- spec/jstd-runner/monitorable_spec.rb
+- spec/jstd-runner/runner_spec.rb
+- spec/jstd-runner/server_spec.rb
+- spec/jstd-runner/vnc_control_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/jarib/jstd-runner
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: JsTestDriver wrapper
+test_files: []
+