jcukeforker 0.2.2

data/lib/jcukeforker/scenarios.rb

@@ -0,0 +1,43 @@
+require 'cucumber/runtime/features_loader'
+
+module JCukeForker
+
+  #
+  # CukeForker::Scenarios.by_args(args)
+  #
+  # where 'args' is a String of cucumber options
+  #
+  # For example:
+  # CukeForker::Scenarios.by_args(%W[-p my_profile -t @edition])
+  # will return an array of scenarios and their line numbers that match
+  # the tags specified in the cucumber profile 'my_profile' AND have the '@edition' tag
+  #
+
+  class Scenarios
+    def self.by_args(args)
+      options = Cucumber::Cli::Options.new(STDOUT, STDERR, :default_profile => 'default')
+      tagged(options.parse!(args)[:tag_expressions])
+    end
+
+    def self.all
+      any_tag = []
+      tagged any_tag
+    end
+
+    def self.tagged(tags)
+      tag_expression = Gherkin::TagExpression.new(tags)
+      scenario_line_logger = JCukeForker::Formatters::ScenarioLineLogger.new(tag_expression)
+      loader = Cucumber::Runtime::FeaturesLoader.new(feature_files, [], tag_expression)
+
+      loader.features.each do |feature|
+        feature.accept(scenario_line_logger)
+      end
+
+      scenario_line_logger.scenarios
+    end
+
+    def self.feature_files
+      Dir.glob('**/**.feature')
+    end
+  end
+end

data/lib/jcukeforker/status_server.rb

@@ -0,0 +1,37 @@
+
+module JCukeForker
+  class StatusServer
+    include Observable
+    include Celluloid::IO
+
+    finalizer :shutdown
+
+    def initialize(port = '6333')
+      @server = TCPServer.new 'localhost', port
+    end
+
+    def run
+      loop { async.handle_connection @server.accept }
+    end
+
+    def shutdown
+      @server.close if @server
+    end
+
+    def handle_connection(socket)
+      until socket.eof? do
+        raw_message = socket.gets
+        json_obj = JSON.parse raw_message
+        fire json_obj.first, *json_obj[1..-1]
+      end
+      socket.close
+    end
+
+    private
+
+    def fire(*args)
+      changed
+      notify_observers *args
+    end
+  end
+end

data/lib/jcukeforker/task_manager.rb

@@ -0,0 +1,45 @@
+
+module JCukeForker
+  class TaskManager < AbstractListener
+
+    def initialize()
+      @tasks = []
+      @worker_sockets = {}
+    end
+
+    def add(task)
+      @tasks << task
+    end
+
+    def on_worker_register(worker_path)
+      @worker_sockets[worker_path] = UNIXSocket.open worker_path
+      pop_task worker_path
+    end
+
+    def on_task_finished(worker_path, feature, status)
+      pop_task worker_path
+    end
+
+    def on_worker_dead(worker_path)
+     socket = @worker_sockets.delete worker_path
+     socket.close
+    end
+
+    def close
+      @worker_sockets.each {|k, v| v.close}
+    end
+
+    private
+
+    def pop_task(worker_path)
+      task = @tasks.shift || '__KILL__'
+      task = task.to_json if task.is_a? Hash
+
+      if task.empty?
+        puts "-----#{worker_path}...EMPTY TASK!"
+      end
+
+      @worker_sockets[worker_path].puts(task)
+    end
+  end
+end

data/lib/jcukeforker/version.rb

@@ -0,0 +1,3 @@
+module JCukeForker
+  VERSION = "0.2.2"
+end

data/lib/jcukeforker/worker.rb

@@ -0,0 +1,122 @@
+require 'socket'
+require 'securerandom'
+require 'json'
+require 'fileutils'
+require 'cucumber/cli/main'
+require 'observer'
+require 'childprocess'
+require_relative './abstract_listener'
+require_relative './recording_vnc_listener'
+
+module JCukeForker
+  class Worker
+    include Observable
+
+    attr_reader :feature, :format, :out
+
+    def initialize(status_path, task_path, recorder = nil)
+      @status_path = status_path
+      @task_path = task_path
+      if ENV['DISPLAY'] && recorder
+        config = recorder ? {} : JSON.parse(recorder)
+        add_observer JCukeForker::RecordingVncListener.new(self, config)
+      end
+      @status_socket = TCPSocket.new 'localhost', status_path
+      @status = nil
+    end
+
+    def register
+      @worker_server = UNIXServer.new @task_path
+      update_status :on_worker_register
+    end
+
+    def close
+      @worker_server.close
+      @status_socket.close
+    end
+
+    def run
+      worker_socket = @worker_server.accept
+      loop do
+        raw_message = worker_socket.gets
+        if raw_message.nil? then
+          sleep 0.3
+          next
+        end
+        if raw_message.strip == '__KILL__'
+          update_status :on_worker_dead
+          break
+        end
+        set_state raw_message
+        update_status :on_task_starting, feature
+        status = execute_cucumber
+        update_status :on_task_finished, feature, status
+      end
+    end
+
+    def update_status(meth, *args)
+      message = [meth, @task_path]
+      message += args
+
+      changed
+      notify_observers *message
+      @status_socket.puts(message.to_json)
+    end
+
+    def failed?
+      @status.nil? || @status
+    end
+
+    def output
+      File.join out, "#{basename}.#{format}"
+    end
+
+    def stdout
+      File.join out, "#{basename}.stdout"
+    end
+
+    def stderr
+      File.join out, "#{basename}.stderr"
+    end
+
+    def basename
+      @basename ||= feature.gsub(/\W/, '_')
+    end
+
+    def args
+      args = %W[--format #{format} --out #{output}]
+      args += @extra_args
+      args << feature
+
+      args
+    end
+
+    private
+
+    def set_state(raw_message)
+      json_obj = JSON.parse raw_message
+      @format = json_obj['format']
+      @feature = json_obj['feature']
+      @extra_args = json_obj['extra_args']
+      @out = json_obj['out']
+    end
+
+    def execute_cucumber
+      FileUtils.mkdir_p(out) unless File.exist? out
+
+      $stdout.reopen stdout
+      $stderr.reopen stderr
+
+      begin
+        Cucumber::Cli::Main.execute args
+      rescue SystemExit => e
+        @status = e.success?
+      end
+
+      $stdout.flush
+      $stderr.flush
+
+      @status
+    end
+  end
+end

data/lib/jcukeforker/worker_script.rb

@@ -0,0 +1,6 @@
+require_relative './worker'
+
+worker = JCukeForker::Worker.new *$ARGV
+worker.register
+worker.run
+worker.close

data/lib/jcukeforker.rb

@@ -0,0 +1,29 @@
+unless RUBY_PLATFORM =~ /darwin|linux|java/
+  raise "CukeForker only supported on *nix"
+end
+
+
+require "cucumber/cli/main"
+require "vnctools"
+require "fileutils"
+require "observer"
+require "forwardable"
+require "ostruct"
+require "json"
+require "securerandom"
+require "celluloid/io"
+require "celluloid/autostart"
+
+module JCukeForker
+end
+
+require 'jcukeforker/abstract_listener'
+require 'jcukeforker/logging_listener'
+require 'jcukeforker/runner'
+require 'jcukeforker/scenarios'
+require 'jcukeforker/status_server'
+require 'jcukeforker/task_manager'
+require 'jcukeforker/configurable_vnc_server'
+
+require 'jcukeforker/formatters/scenario_line_logger'
+require 'jcukeforker/formatters/junit_scenario_formatter'

data/spec/jcukeforker/formatters/scenario_line_logger_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+require 'cucumber/ast/scenario_outline'
+
+module JCukeForker::Formatters
+  describe ScenarioLineLogger do
+    it "returns scenario names and line numbers for a scenario" do
+      logger = ScenarioLineLogger.new
+
+      feature = double("Cucumber::Ast::Feature")
+      feature_element = double("Cucumber::Ast::Scenario")
+
+      feature.should_receive(:file).twice.and_return('features/test1.feature')
+      feature_element.should_receive(:source_tags).twice.and_return('')
+      feature_element.should_receive(:feature).twice.and_return(feature)
+      feature_element.should_receive(:line).and_return(3)
+      feature_element.should_receive(:line).and_return(6)
+
+      logger.visit_feature_element(feature_element)
+      logger.visit_feature_element(feature_element)
+
+      logger.scenarios.length.should == 2
+      logger.scenarios[0].should == "features/test1.feature:3"
+      logger.scenarios[1].should == "features/test1.feature:6"
+    end
+
+    it "returns scenario names and line numbers for a scenario outline" do
+      logger = ScenarioLineLogger.new
+
+      feature = double("Cucumber::Ast::Feature")
+      location = double("Cucumber::Ast::Location", :line => 4)
+      feature_element = Cucumber::Ast::ScenarioOutline.new(*Array.new(11) {|a| double(a, :each => true) })
+      feature_element.stub(:location => location)
+
+      feature.should_receive(:file).and_return('features/test1.feature')
+      feature_element.should_receive(:source_tags).and_return('')
+      feature_element.should_receive(:feature).and_return(feature)
+
+      logger.visit_feature_element(feature_element)
+
+      logger.scenarios.length.should == 1
+      logger.scenarios[0].should == "features/test1.feature:4"
+    end
+  end
+end

data/spec/jcukeforker/logging_listener_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module JCukeForker
+  describe LoggingListener do
+    let(:stdout)   { StringIO.new }
+    let(:listener) { LoggingListener.new stdout }
+
+    it "logs all events" do
+      Time.stub(:now => Time.now)
+
+      mock_worker = {:path => '/tmp/12sd3-1', :feature => 'foo/bar', :failed? => 'true'}
+      mock_worker2 = {:path => '/tmp/12sd3-15', :feature => 'foo/baz', :failed? => 'false'}
+
+      listener.on_run_starting
+      listener.on_worker_register mock_worker[:path]
+      listener.on_task_starting mock_worker[:path], mock_worker[:feature]
+      listener.on_worker_register mock_worker2[:path]
+      listener.on_task_starting mock_worker2[:path], mock_worker2[:feature]
+      listener.on_task_finished mock_worker[:path], mock_worker[:feature], mock_worker[:failed?]
+      listener.on_task_finished mock_worker2[:path], mock_worker2[:feature], mock_worker2[:failed?]
+      listener.on_worker_dead mock_worker[:path]
+      listener.on_worker_dead mock_worker2[:path]
+      listener.on_run_interrupted
+      listener.on_run_finished false
+
+      timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S##{Process.pid}")
+
+      stdout.string.should == <<-OUTPUT
+I, [#{timestamp}]  INFO -- : [    run           ] starting
+I, [#{timestamp}]  INFO -- : [    worker  1     ] register: /tmp/12sd3-1
+I, [#{timestamp}]  INFO -- : [    worker  1     ] starting: foo/bar
+I, [#{timestamp}]  INFO -- : [    worker  15    ] register: /tmp/12sd3-15
+I, [#{timestamp}]  INFO -- : [    worker  15    ] starting: foo/baz
+I, [#{timestamp}]  INFO -- : [    worker  1     ] passed  : foo/bar
+I, [#{timestamp}]  INFO -- : [    worker  15    ] failed  : foo/baz
+I, [#{timestamp}]  INFO -- : [    worker  1     ] dead    : /tmp/12sd3-1
+I, [#{timestamp}]  INFO -- : [    worker  15    ] dead    : /tmp/12sd3-15
+I, [#{timestamp}]  INFO -- : [    run           ] interrupted - please wait
+I, [#{timestamp}]  INFO -- : [    run           ] finished, passed
+      OUTPUT
+    end
+  end # Worker
+end # CukeForker

data/spec/jcukeforker/recording_vnc_listener_spec.rb

@@ -0,0 +1,81 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module JCukeForker
+  describe RecordingVncListener do
+    let(:worker)       { double(Worker, :out => ".", :basename => "foo", :failed? => true) }
+    let(:recorder)     { double(ChildProcess, :start => nil, :stop => nil, :io => double('io').as_null_object, :crashed? => false) }
+    let(:listener)     { RecordingVncListener.new worker }
+
+    it "starts recording when the task is started" do
+      worker_path = 'worker_path'
+      feature = 'feature'
+
+      env = ENV['DISPLAY']
+      ENV['DISPLAY']= ':1'
+      ChildProcess.should_receive(:build).with(
+        'ffmpeg',
+        '-an',
+        '-y',
+        '-f', 'x11grab',
+        '-r', '5',
+        '-s', '1024x768',
+        '-i', ':1',
+        '-vcodec', 'vp8',
+        './feature.webm'
+      ).and_return(recorder)
+
+      recorder.should_receive(:start)
+
+      listener.on_task_starting worker, feature
+      ENV['DISPLAY'] = env
+    end
+
+    it "stops recording when the task is finished" do
+      recorder.should_receive(:stop)
+      listener.instance_variable_set(:@recorder, recorder)
+
+      listener.on_task_finished worker, nil, nil
+
+      listener.instance_variable_get(:@recorder).should be_nil
+    end
+
+    it "stops recording when worker dies" do
+      listener.instance_variable_set(:@recorder, recorder)
+      recorder.should_receive(:stop)
+
+      listener.on_worker_dead(nil)
+    end
+
+    it "deletes the output file if the worker succeeded" do
+      recorder.stub(:stop)
+      listener.instance_variable_set(:@recorder, recorder)
+
+      worker.should_receive(:failed?).and_return(false)
+      listener.should_receive(:output).and_return("./foo.mp4")
+      FileUtils.should_receive(:rm_rf).with("./foo.mp4")
+
+      listener.on_task_finished worker, nil, nil
+    end
+
+    it "passes along options to recorder" do
+      listener = RecordingVncListener.new worker, :codec => "flv"
+      env = ENV['DISPLAY']
+      ENV['DISPLAY']= ':1'
+      ChildProcess.should_receive(:build).with(
+        'ffmpeg',
+        '-an',
+        '-y',
+        '-f', 'x11grab',
+        '-r', '5',
+        '-s', '1024x768',
+        '-i', ':1',
+        '-vcodec', 'flv',
+        './feature.flv'
+      ).and_return(recorder)
+
+      listener.on_task_starting worker, 'feature'
+      env = ENV['DISPLAY']
+    end
+
+  end # RecordingVncListener
+end # CukeForker