spassky 0.1.0

data/lib/spassky/client/cli.rb

@@ -0,0 +1,12 @@
+require 'spassky/client/test_runner'
+require 'spassky/client/pusher'
+require 'spassky/client/directory_reader'
+
+module Spassky::Client
+  class Cli
+    def self.run(argv)
+      writer = argv.include?('--colour') ? ColouredWriter : DefaultWriter
+      TestRunner.new(Pusher.new(argv[0]), writer.new(STDOUT), DirectoryReader.new).run_tests(argv[1])
+    end
+  end
+end

data/lib/spassky/client/directory_reader.rb

@@ -0,0 +1,14 @@
+module Spassky::Client
+  class DirectoryReader
+    def read_files(pattern)
+      if File.file? pattern
+        { pattern => File.read(pattern) }
+      elsif File.directory? pattern
+        Dir.glob(pattern + "/*").inject({}) do |hash, path|
+          hash[File.basename(path)] = File.read(path)
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/spassky/client/pusher.rb

@@ -0,0 +1,36 @@
+require 'rest-client'
+require 'spassky/test_result'
+
+module Spassky::Client
+  class Pusher
+    def initialize(server_url, sleeper=Kernel)
+      @server_url = server_url
+      @sleeper = sleeper
+    end
+
+    def test_runs_url
+      test_runs_url = @server_url.gsub(/\/$/, "") + "/test_runs"
+    end
+
+    def push(options)
+      location = post_test(options)
+      result = nil
+      begin
+        result = Spassky::TestResult.from_json(RestClient.get(location))
+        yield result
+        @sleeper.sleep 0.4 if result.status == 'in progress'
+      end while result.status == 'in progress'
+    end
+
+    private
+
+    def post_test(options)
+      location = nil
+      RestClient.post(test_runs_url, options) do |response, request, result|
+        location = response.headers[:location]
+      end
+      raise "Expected #{test_runs_url} to respond with 302" unless location
+      location
+    end
+  end
+end

data/lib/spassky/client/test_runner.rb

@@ -0,0 +1,44 @@
+require 'spassky/client/writer'
+
+module Spassky::Client
+  class TestRunner
+    def initialize(pusher, writer, directory_reader)
+      @pusher = pusher
+      @writer = writer
+      @directory_reader = directory_reader
+    end
+
+    def run_tests(pattern)
+      previous_test_result = nil
+      test_name = File.basename(pattern)
+      @pusher.push(:name => test_name, :contents => @directory_reader.read_files(pattern).to_json) do |result|
+        handle_test_result(previous_test_result, result)
+        previous_test_result = result
+      end
+    end
+
+    def handle_test_result(previous_test_result, test_result)
+      write_in_progress_status previous_test_result, test_result
+      unless test_result.status == "in progress"
+        write(test_result.status, test_result.summary)
+      end
+      write_exit_code(test_result)
+    end
+
+    def write_in_progress_status previous_test_result, test_result
+      test_result.completed_since(previous_test_result).each do |device_test_status|
+        write(device_test_status.status, "#{device_test_status.status.upcase} #{device_test_status.test_name} on #{device_test_status.user_agent}")
+      end
+    end
+
+    def write status, message
+      method = status == 'pass' ? :write_passing : :write_failing
+      @writer.send(method, message)
+    end
+
+    def write_exit_code(result)
+      Kernel.exit(1) if result.status == 'fail'
+      Kernel.exit(2) if result.status == 'timed out'
+    end
+  end
+end

data/lib/spassky/client/writer.rb

@@ -0,0 +1,31 @@
+require 'rainbow'
+
+module Spassky::Client
+  class DefaultWriter
+    def initialize(output)
+      @output = output
+    end
+    
+    def write_passing(text)
+      @output.puts text
+    end
+    
+    def write_failing(text)
+      @output.puts text
+    end
+  end
+  
+  class ColouredWriter
+    def initialize(output)
+      @output = output
+    end
+    
+    def write_passing(text)
+      @output.puts text.color(:green)
+    end
+    
+    def write_failing(text)
+      @output.puts text.color(:red)
+    end
+  end
+end

data/lib/spassky/client.rb

@@ -0,0 +1 @@
+require 'spassky/client/cli'

data/lib/spassky/server/app.rb

@@ -0,0 +1,76 @@
+require 'sinatra/base'
+require 'spassky/server/random_string_generator'
+require 'spassky/server/test_run'
+require 'spassky/server/device_list'
+require 'spassky/server/html_test'
+
+module Spassky::Server
+  class App < Sinatra::Base
+    def initialize(device_list=DeviceList.new)
+      @device_list = device_list
+      super()
+    end
+
+    get "/devices/clear" do
+      @device_list.clear
+    end
+
+    get '/device/connect' do
+      redirect idle_url
+    end
+
+    get '/device/idle/:random' do
+      test_run = TestRun.find_next_to_run_for_user_agent(request.user_agent)
+      @device_list.update_last_connected(request.user_agent)
+      if test_run
+        redirect_to_run_tests(test_run)
+      else
+        idle_page
+      end
+    end
+
+    post '/test_runs' do
+      run = TestRun.create({
+        :name => params[:name],
+        :contents => JSON.parse(params[:contents]),
+        :devices => @device_list.recently_connected_devices
+      })
+      redirect "/test_runs/#{run.id}"
+    end
+
+    get '/test_runs/:id' do
+      run = TestRun.find(params[:id])
+      run.update_connected_devices(@device_list.recently_connected_devices)
+      run.result.to_json
+    end
+
+    get '/test_runs/:id/run/:random/assert' do
+      TestRun.find(params[:id]).save_results_for_user_agent(
+        :user_agent => request.user_agent,
+        :status => params[:status]
+      )
+    end
+
+    get '/test_runs/:id/run/:random/:file_name' do
+      test_run = TestRun.find(params[:id])
+      test_name = params[:file_name]
+      HtmlTest.new(test_run.contents, idle_url, 1).get_file(test_name)
+    end
+
+    private
+
+    def redirect_to_run_tests(test_run)
+      redirect "/test_runs/#{test_run.id}/run/#{RandomStringGenerator.random_string}/#{test_run.name}"
+    end
+
+    def idle_url
+      "/device/idle/#{RandomStringGenerator.random_string}"
+    end
+
+    def idle_page
+      "<html><head><meta http-equiv=\"refresh\" content=\"1; url='#{idle_url}'\"></head>" +
+      "<body>Idle #{RandomStringGenerator.random_string}</body>" +
+      "</html>"
+    end
+  end
+end

data/lib/spassky/server/assert.js

@@ -0,0 +1,5 @@
+function assert(status, message) {
+  var img = document.createElement('img');
+  img.setAttribute('src', 'assert?status=' + (status ? 'pass' : 'fail') + '&message=' + escape(message));
+  document.body.appendChild(img);
+}

data/lib/spassky/server/device_list.rb

@@ -0,0 +1,18 @@
+module Spassky::Server
+  class DeviceList
+    def update_last_connected user_agent
+      @devices_and_time_last_connected ||= {}
+      @devices_and_time_last_connected[user_agent] = Time.now  
+    end
+    
+    def recently_connected_devices
+      @devices_and_time_last_connected.keys.select do |user_agent|
+        Time.now.to_f - @devices_and_time_last_connected[user_agent].to_f < 3
+      end
+    end
+    
+    def clear
+      @devices_and_time_last_connected = {}
+    end
+  end
+end

data/lib/spassky/server/html_test.rb

@@ -0,0 +1,27 @@
+module Spassky::Server
+  class HtmlTest
+    def initialize(contents, url, seconds)
+      @contents = contents
+      @meta_refresh_tag = "<meta http-equiv=\"refresh\" content=\"#{seconds}; url='#{url}'\">"
+    end
+
+    def get_file(name)
+      file_contents = @contents[name]
+      unless file_contents
+        html_file = @contents.keys.find {|key| key.end_with?(".html")}
+        file_contents = @contents[html_file]
+      end
+      file_contents.gsub('</head>', assert_js_script_tag + @meta_refresh_tag + '</head>')
+    end
+
+    private
+
+    def assert_js_script_tag
+      "<script type=\"text/javascript\">#{assert_js_script}</script>"
+    end
+
+    def assert_js_script
+      File.read(File.join(File.dirname(__FILE__), 'assert.js'))
+    end
+  end
+end

data/lib/spassky/server/random_string_generator.rb

@@ -0,0 +1,7 @@
+module Spassky::Server
+  class RandomStringGenerator
+    def self.random_string
+      Time.now.to_i.to_s
+    end
+  end
+end

data/lib/spassky/server/test_run.rb

@@ -0,0 +1,64 @@
+require 'spassky/test_result'
+
+module Spassky::Server
+  class TestRun
+    attr_accessor :name, :contents, :id
+
+    def initialize(options)
+      @name = options[:name]
+      @contents = options[:contents]
+      @status_by_user_agent = {}
+      (options[:devices] || []).each do |device|
+        @status_by_user_agent[device] = "in progress"
+      end
+    end
+
+    def run_by_user_agent?(user_agent)
+      @status_by_user_agent[user_agent] != "in progress"
+    end
+
+    def save_results_for_user_agent(options)
+      unless ['pass', 'fail'].include? options[:status]
+        raise "#{options[:status]} is not a valid status"
+      end
+      @status_by_user_agent[options[:user_agent]] = options[:status]
+    end
+
+    def update_connected_devices(user_agents)
+      @status_by_user_agent.each do |user_agent, status|
+        if !user_agents.include?(user_agent) && status == "in progress"
+          @status_by_user_agent[user_agent] = "timed out"
+        end
+      end
+    end
+
+    def result
+      Spassky::TestResult.new(@status_by_user_agent.map { |user_agent, status|
+        Spassky::DeviceTestStatus.new(user_agent, status, name)
+      })
+    end
+
+    def self.create(options)
+      new_test_run = TestRun.new(options)
+      new_test_run.id = test_runs.size
+      test_runs << new_test_run
+      new_test_run
+    end
+
+    def self.find(id)
+      test_runs.find { |test_run| test_run.id.to_s == id.to_s  }
+    end
+
+    def self.find_next_to_run_for_user_agent(user_agent)
+      test_runs.find { |test_run| test_run.run_by_user_agent?(user_agent) == false }
+    end
+
+    def self.delete_all
+      @test_runs = []
+    end
+
+    def self.test_runs
+      @test_runs ||= []
+    end
+  end
+end

data/lib/spassky/server.rb

@@ -0,0 +1 @@
+require 'spassky/server/app'

data/lib/spassky/test_result.rb

@@ -0,0 +1,110 @@
+require 'json'
+
+module Spassky
+  class TestResult
+    attr_reader :device_statuses
+    def initialize device_statuses
+      @device_statuses = device_statuses
+    end
+    
+    def status
+      statuses = @device_statuses.map { |s| s.status }.uniq
+      return "in progress" if statuses.include?("in progress") || statuses.size == 0
+      return "fail" if statuses.include?("fail")
+      return "timed out" if statuses.include?("timed out")
+      "pass"
+    end
+    
+    def count_fails
+      @device_statuses.count { |s| s.status == "fail" }
+    end
+    
+    def count_timeouts
+      @device_statuses.count { |s| s.status == "timed out" }
+    end
+    
+    def completed_since(older_test_result)
+      if older_test_result.nil?
+        device_statuses.select { |s| s.completed? }
+      else
+        find_newly_completed_device_results(older_test_result)
+      end
+    end
+    
+    def summary
+      result = "?"
+      count = @device_statuses.size
+      if count_timeouts > 0
+        result = "1 test timed out on #{count} device"
+      else
+        status = "passed"
+        fail_count = count_fails
+        if fail_count > 0
+          status = "failed"
+          count = fail_count
+        end
+        result = "1 test #{status} on #{count} device"
+      end
+      result << "s" if @device_statuses.size > 1
+      return result
+    end
+    
+    def to_json
+      {
+        :status => "pass",
+        :device_statuses => @device_statuses.map do |status|
+          {
+            :user_agent => status.user_agent,
+            :status => status.status,
+            :test_name => status.test_name
+          }
+        end
+      }.to_json
+    end
+    
+    def self.from_json json
+      parsed = JSON.parse(json)
+      test_result = TestResult.new(
+        parsed['device_statuses'].map do |t|
+          DeviceTestStatus.new(t["user_agent"], t["status"], t["test_name"])
+        end
+      )
+    end
+    
+    private
+    
+    def find_newly_completed_device_results(older_test_result)
+      completed = []
+      before_and_after(older_test_result) do |before, after|
+        if before.in_progress? && after.completed?
+          completed << after
+        end
+      end
+      completed
+    end
+    
+    def before_and_after(older_test_result)
+      device_statuses.each_with_index do |s, i|
+        yield older_test_result.device_statuses[i], s
+      end
+    end
+  end
+  
+  class DeviceTestStatus
+    attr_reader :user_agent, :status, :test_name
+    
+    def initialize(user_agent, status, test_name)
+      @user_agent = user_agent
+      @status = status
+      @test_name = test_name
+    end
+    
+    def in_progress?
+      @status == "in progress"
+    end
+    
+    def completed?
+      @status != "in progress"
+    end
+  end
+end

data/lib/spassky/version.rb

@@ -0,0 +1,3 @@
+module Spassky
+  VERSION = '0.1.0'
+end

data/lib/spassky.rb

@@ -0,0 +1,9 @@
+$:.unshift(File.dirname(__FILE__)) unless
+$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module Spassky
+  module Server
+  end
+  module Client
+  end
+end

data/spassky.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "spassky/version"
+
+Gem::Specification.new do |s|
+  s.name        = "spassky"
+  s.version     = Spassky::VERSION
+  s.authors     = ["Joshua Chisholm", "Andrew Vos", "Adrian Lewis"]
+  s.email       = ["andrew.vos@gmail.com"]
+  s.homepage    = "http://github.com/BBC/spassky"
+  s.summary     = %q{}
+  s.description = %q{}
+
+  s.rubyforge_project = "spassky"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'rest-client'
+  s.add_dependency 'json'
+  s.add_dependency 'sinatra'
+  s.add_dependency 'rainbow'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'cucumber'
+  s.add_development_dependency 'capybara'
+  s.add_development_dependency 'aruba'
+end

data/spec/spassky/client/cli_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'spassky/client/cli'
+
+module Spassky::Client
+  describe Cli do
+    let :pusher do
+      mock(:pusher)
+    end
+
+    let :runner do
+      mock(:runner, :run_tests => true)
+    end
+
+    before do
+      Pusher.stub!(:new).and_return(pusher)
+      TestRunner.stub!(:new).and_return(runner)
+    end
+
+    it "creates a pusher with the server url as the first argument" do
+      Pusher.should_receive(:new).with("server_name").and_return(pusher)
+      TestRunner.should_receive(:new).with(pusher, anything(), anything()).and_return(runner)
+      Cli::run(["server_name", "test_name"])
+    end
+
+    it "runs a single test with the name as the second argument" do
+      runner.should_receive(:run_tests).with("test_name")
+      Cli::run(["server_name", "test_name"])
+    end
+
+    context "without colour output option" do
+      it "creates a test runner with a default writer" do
+        default_writer = mock :default_writer
+        DefaultWriter.should_receive(:new).with(STDOUT).and_return(default_writer)
+        TestRunner.should_receive(:new).with(anything(), default_writer, anything())
+        Cli::run(["server_name", "test_name"])
+      end
+    end
+
+    context "with colour output option" do
+      it "creates a test runner with a colour writer" do
+        coloured_writer = mock :coloured_writer
+        ColouredWriter.should_receive(:new).with(STDOUT).and_return(coloured_writer)
+        TestRunner.should_receive(:new).with(anything(), coloured_writer, anything())
+        Cli::run(["server_name", "test_name", "--colour"])
+      end
+    end
+  end
+end

data/spec/spassky/client/directory_reader_spec.rb

@@ -0,0 +1,35 @@
+require 'spassky/client/directory_reader'
+
+module Spassky::Client
+  describe DirectoryReader do
+    context "when given a file name" do
+      it "returns a hash with one file" do
+        File.should_receive(:file?).and_return(true)
+        File.should_receive(:read).with("foo").and_return("content")
+        DirectoryReader.new.read_files("foo").should == {
+          "foo" => "content"
+        }
+      end
+    end
+    context "when given a directory name" do
+      it "globs for files in the specified directory" do
+        File.stub!(:file?).and_return(false)
+        File.stub!(:directory?).and_return(true)
+        Dir.should_receive(:glob).with("directory/*").and_return([])
+        DirectoryReader.new.read_files("directory")
+      end
+
+      it "returns a hash with all files in that directory" do
+        File.stub!(:file?).and_return(false)
+        File.stub!(:directory?).and_return(true)
+        Dir.stub!(:glob).and_return ["directory/file1", "directory/file2"]
+        File.stub!(:read).with("directory/file1").and_return("file 1 contents")
+        File.stub!(:read).with("directory/file2").and_return("file 2 contents")
+        DirectoryReader.new.read_files("directory").should == {
+          "file1" => "file 1 contents",
+          "file2" => "file 2 contents"
+        }
+      end
+    end
+  end
+end

data/spec/spassky/client/pusher_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'spassky/client/pusher'
+
+module Spassky::Client
+  describe Pusher do
+    before do
+      @response = mock("response", :code => 302, :headers => { :location => "http://poll/me" })
+      @server_url = "http://foo/"
+      @sleeper = mock("sleeper")
+      @sleeper.stub!(:sleep)
+      @pusher = Pusher.new(@server_url, @sleeper)
+      RestClient.stub!(:post).with("http://foo/test_runs", "test contents"
+        ).and_yield(@response, nil, nil)
+      RestClient.stub!(:get).and_return(passed_status)
+    end
+
+    def in_progress_status
+      Spassky::TestResult.new([Spassky::DeviceTestStatus.new('agent', 'in progress', 'test')]).to_json
+    end
+
+    def passed_status
+      Spassky::TestResult.new([Spassky::DeviceTestStatus.new('agent', 'pass', 'test')]).to_json
+    end
+
+    def failed_status
+      Spassky::TestResult.new([Spassky::DeviceTestStatus.new('agent', 'fail', 'test')]).to_json
+    end
+
+    it "pushes a test to the server" do
+      RestClient.should_receive(:post).with("http://foo/test_runs", {:contents => 'test contents'}
+        ).and_yield(@response, nil, nil)
+      @pusher.push({:contents => "test contents"}) do |result|
+      end
+    end
+
+    it "fails nicely when the url does not redirect" do
+      @response = mock("response", :code => 200, :headers => { })
+      RestClient.stub!(:post).with("http://foo/test_runs", "test contents"
+        ).and_yield(@response, nil, nil)
+      lambda {
+        @pusher.push("test contents") do |result|
+        end
+      }.should raise_error("Expected http://foo/test_runs to respond with 302")
+    end
+
+    it "polls the URL returned until the test passes" do
+      RestClient.should_receive(:get).with("http://poll/me").and_return(in_progress_status, in_progress_status, in_progress_status, passed_status)
+      @pusher.push("test contents") do |result|
+      end
+    end
+
+    it "polls the URL returned until the test fails" do
+      RestClient.should_receive(:get).and_return(in_progress_status, in_progress_status, failed_status)
+      @pusher.push("test contents") {}
+    end
+
+    it "yields the outcome of the test to the block" do
+      RestClient.stub!(:get).and_return(in_progress_status, in_progress_status, passed_status)
+      yielded_results = []
+      @pusher.push("test contents") do |result|
+        yielded_results << result.to_json
+      end
+      yielded_results.should == [in_progress_status, in_progress_status, passed_status]
+    end
+
+    it "sleeps while looping during get requests" do
+      RestClient.stub!(:get).and_return(in_progress_status, in_progress_status, in_progress_status, passed_status)
+      @sleeper.should_receive(:sleep).with(0.4).exactly(3).times
+      @pusher.push("test contents") { |result| }
+    end
+  end
+end