jcukeforker 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 32563d887a984beb002a2661539769d5908beeb3
+  data.tar.gz: 602298483da878759729ab39644dfae2058012d9
+SHA512:
+  metadata.gz: f956f1cc6927646155a24209b2b796a058818a39ca038df79e7f4de673ea15803840a8bba9f638d6dd658c2a6c8c0f34b5a76bcd474321e50404561249d2345e
+  data.tar.gz: 4245453e0c2a25cc5cfe430932cf499fbd4fbeb2ff6fa312c2724b380543b6981ab8eeb7f8cbd86c6c5771fb01a044a1b816ffd73efdbfc79d19c941fbc0d0f1

data/.gitignore

@@ -0,0 +1,9 @@
+pkg/*
+*.gem
+.bundle
+Gemfile.lock
+\#*
+.\#*
+.idea
+.ruby-version
+/coverage

data/.rspec

@@ -0,0 +1 @@
+--color -fs

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011-2014 Jari Bakken
+
+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.mdown

@@ -0,0 +1,45 @@
+# jcukeforker
+
+Forking cukes and VNC displays.
+
+Jcukeforker is a fork of cukeforker desgined for jruby.
+
+### NB!
+
+If you're using cukeforker with selenium-webdriver and Firefox, all versions prior to 2.40 has a bug where custom
+Firefox profiles created in a forked process would not get cleaned up. Please make sure you're using selenium-webdriver >= 2.40
+to avoid this.
+
+## Usage
+
+
+```ruby
+    # parallelize per feature
+    JCukeForker::Runner.run Dir['features/**/*.feature'],
+                           :max        => 4                     # number of workers
+                           :out        => "/path/to/reports",   # output path
+                           :format     => :html                 # passed to `cucumber --format`,
+                           :extra_args => %w[--extra arguments] # passed to cucumber,
+                           :vnc        => true                  # manage a pool of VNC displays, assign one per worker.
+
+    # parallelize per scenario, with one JUnit XML file per scenario.
+    JCukeForker::Runner.run JCukeForker::Scenarios.tagged(%W[@edition ~@wip])
+                           :extra_args => %W[-f CukeForker::Formatters::JunitScenarioFormatter --out results/junit]
+```
+
+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) 2011-2014 Jari Bakken. 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/bin/cukeforker

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'cukeforker'
+
+split      = ARGV.index("--")
+extra_args = ARGV[0..(split-1)]
+features   = ARGV[(split+1)..-1]
+
+CukeForker::Runner.run(features, :extra_args => extra_args)

data/jcukeforker.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "jcukeforker/version"
+
+Gem::Specification.new do |s|
+  s.name        = "jcukeforker"
+  s.version     = JCukeForker::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jason Gowan", "Jari Bakken"]
+  s.email       = ["gowanjason@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Library to maintain a forking queue of Cucumber processes}
+  s.description = %q{Library to maintain a forking queue of Cucumber processes, with optional VNC displays.}
+
+  s.rubyforge_project = "jcukeforker"
+
+  s.add_dependency "cucumber", ">= 1.1.5"
+  s.add_dependency "vnctools", ">= 0.1.1"
+  s.add_dependency "celluloid-io", ">= 0.15.0"
+  s.add_dependency "childprocess", ">= 0.5.3"
+  s.add_development_dependency "rspec", "~> 2.5"
+  s.add_development_dependency "coveralls"
+  s.add_development_dependency "rake", "~> 0.9.2"
+
+  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"]
+end

data/lib/jcukeforker/abstract_listener.rb

@@ -0,0 +1,57 @@
+module JCukeForker
+  class AbstractListener
+
+    def on_run_starting
+    end
+
+    def on_worker_waiting(worker_path)
+    end
+
+    def on_worker_dead(worker_path)
+    end
+
+    def on_task_starting(worker_path, feature)
+    end
+
+    def on_task_finished(worker_path, feature, status)
+    end
+
+    def on_worker_forked(worker)
+    end
+
+    def on_worker_register(worker_path)
+    end
+
+    def on_worker_waiting(worker_path)
+    end
+
+    def on_worker_dead(worker_path)
+    end
+
+    def on_run_interrupted
+    end
+
+    def on_run_finished(failed)
+    end
+
+    def on_display_fetched(server)
+    end
+
+    def on_display_released(server)
+    end
+
+    def on_display_starting(worker_path, display)
+    end
+
+    def on_display_stopping(worker_path, display)
+    end
+
+    def on_eta(time, remaining, finished)
+    end
+
+    def update(meth, *args)
+      __send__(meth, *args)
+    end
+
+  end # AbstractListener
+end # CukeForker

data/lib/jcukeforker/configurable_vnc_server.rb

@@ -0,0 +1,16 @@
+
+module JCukeForker
+  class ConfigurableVncServer
+
+    def self.create_class(launch_arguments)
+      Class.new(VncTools::Server) do
+
+        define_method :launch_arguments do
+          launch_arguments
+        end
+      end
+    end
+  end
+end
+
+

data/lib/jcukeforker/formatters/junit_scenario_formatter.rb

@@ -0,0 +1,40 @@
+require 'cucumber/formatter/junit'
+require 'cucumber/formatter/ordered_xml_markup'
+module JCukeForker
+  module Formatters
+    class JunitScenarioFormatter < Cucumber::Formatter::Junit
+      def feature_result_filename(feature_file)
+        File.join(@reportdir, "TEST-#{basename(feature_file)}.xml")
+      end
+
+      def after_feature(feature)
+        # do nothing
+      end
+
+      def feature_element_line_number(feature_element)
+        if feature_element.respond_to? :line
+          feature_element.line
+        else
+          feature_element.instance_variable_get(:@line)
+        end
+      end
+
+      def after_feature_element(feature_element)
+        @testsuite = Cucumber::Formatter::OrderedXmlMarkup.new( :indent => 2 )
+        @testsuite.instruct!
+        @testsuite.testsuite(
+          :failures => @failures,
+          :errors => @errors,
+          :skipped => @skipped,
+          :tests => @tests,
+          :time => "%.6f" % @time,
+          :name => @feature_name ) do
+          @testsuite << @builder.target!
+        end
+
+        line_number = feature_element_line_number(feature_element)
+        write_file(feature_result_filename(feature_element.feature.file+"-#{line_number}"), @testsuite.target!)
+      end
+    end
+  end
+end

data/lib/jcukeforker/formatters/scenario_line_logger.rb

@@ -0,0 +1,28 @@
+require 'gherkin/tag_expression'
+module JCukeForker
+  module Formatters
+    class ScenarioLineLogger
+      attr_reader :scenarios
+
+      def initialize(tag_expression = Gherkin::TagExpression.new([]))
+        @scenarios = []
+        @tag_expression = tag_expression
+      end
+
+      def visit_feature_element(feature_element)
+        if @tag_expression.evaluate(feature_element.source_tags)
+          line_number = if feature_element.respond_to?(:line)
+                          feature_element.line
+                        else
+                          feature_element.location.line
+                        end
+
+          @scenarios << [feature_element.feature.file, line_number].join(':')
+        end
+      end
+
+      def method_missing(*args)
+      end
+    end
+  end
+end

data/lib/jcukeforker/logging_listener.rb

@@ -0,0 +1,59 @@
+require "logger"
+
+module JCukeForker
+  class LoggingListener < AbstractListener
+    TIME_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+    def initialize(io = STDOUT)
+      @io = io
+    end
+
+    def on_run_starting
+      log.info "[    run           ] starting"
+    end
+
+    def on_worker_register(worker_path)
+      log.info "[    worker  #{worker_id(worker_path).ljust 3}   ] register: #{worker_path}"
+    end
+
+    def on_worker_dead(worker_path)
+      log.info "[    worker  #{worker_id(worker_path).ljust 3}   ] dead    : #{worker_path}"
+    end
+
+    def on_task_starting(worker_path, feature)
+      log.info "[    worker  #{worker_id(worker_path).ljust 3}   ] starting: #{feature}"
+    end
+
+    def on_task_finished(worker_path, feature, status)
+      log.info "[    worker  #{worker_id(worker_path).ljust 3}   ] #{status_string(status).ljust(8)}: #{feature}"
+    end
+
+    def on_run_finished(failed)
+      log.info "[    run           ] finished, #{status_string failed}"
+    end
+
+    def on_run_interrupted
+      puts "\n"
+      log.info "[    run           ] interrupted - please wait"
+    end
+
+    private
+
+    def status_string(failed)
+      failed == 'false' ? 'failed' : 'passed'
+    end
+
+    def worker_id(worker_path)
+      /\-(\d+)$/.match(worker_path).captures[0]
+    end
+
+    def log
+      @log ||= (
+        log = Logger.new @io
+        log.datetime_format = TIME_FORMAT
+
+        log
+      )
+    end
+  end # LoggingListener
+end # CukeForker

data/lib/jcukeforker/recording_vnc_listener.rb

@@ -0,0 +1,60 @@
+
+module JCukeForker
+  class RecordingVncListener < AbstractListener
+
+    attr_reader :output
+
+    def initialize(worker, opts = {})
+      @ext      = opts[:codec] || "webm"
+      @options  = opts
+      @worker = worker
+
+      @recorder = nil
+    end
+
+    def on_task_starting(worker_path, feature)
+
+      @recorder = recorder_for(feature)
+      @recorder.start
+    end
+
+    def on_task_finished(worker, feature, status)
+      if @recorder.crashed?
+        raise 'ffmpeg failed'
+      end
+
+      unless worker.failed?
+        FileUtils.rm_rf output
+      end
+
+      @recorder.stop
+
+      @recorder = nil
+    end
+
+    def on_worker_dead(worker_path)
+      @recorder && @recorder.stop
+    end
+
+    private
+
+    def recorder_for(feature)
+      @output  = File.join(@worker.out, "#{feature.gsub(/\W/, '_')}.#{@ext}")
+
+      process = ChildProcess.build(
+        'ffmpeg',
+        '-an',
+        '-y',
+        '-f', 'x11grab',
+        '-r', @options[:frame_rate] || '5',
+        '-s', @options[:frame_size] || '1024x768',
+        '-i', ENV['DISPLAY'],
+        '-vcodec', @options[:codec] || 'vp8',
+        @output
+      )
+      process.io.stdout = process.io.stderr = File.open('/dev/null', 'w')
+      process
+    end
+
+  end # RecordingVncListener
+end # CukeForker

data/lib/jcukeforker/runner.rb

@@ -0,0 +1,155 @@
+module JCukeForker
+
+  #
+  # Runner.run(features, opts)
+  #
+  # where 'features' is an Array of file:line
+  # and 'opts' is a Hash of options:
+  #
+  #   :max        => Fixnum            number of workers (default: 2, pass 0 for unlimited)
+  #   :vnc        => true/false,Class,Array  children are launched with DISPLAY set from a VNC server pool,
+  #                                    where the size of the pool is equal to :max. If passed a Class instance,
+  #                                    this will be passed as the second argument to VncTools::ServerPool.
+  #   :record     => true/false,Hash   whether to record a video of failed tests (requires ffmpeg)
+  #                                    this will be ignored if if :vnc is not true. If passed a Hash,
+  #                                    this will be passed as options to RecordingVncListener
+  #   :notify     => object            (or array of objects) implementing the AbstractListener API
+  #   :out        => path              directory to dump output to (default: current working dir)
+  #   :log        => true/false        wether or not to log to stdout (default: true)
+  #   :format     => Symbol            format passed to `cucumber --format` (default: html)
+  #   :extra_args => Array             extra arguments passed to cucumber
+  #   :delay      => Numeric           seconds to sleep between each worker is started (default: 0)
+  #
+
+  class Runner
+    include Observable
+
+    DEFAULT_OPTIONS = {
+      :max    => 2,
+      :vnc    => false,
+      :record => false,
+      :notify => nil,
+      :out    => Dir.pwd,
+      :log    => true,
+      :format => :html,
+      :delay  => 0
+    }
+
+    def self.run(features, opts = {})
+      create(features, opts).run
+    end
+
+    def self.create(features, opts = {})
+      opts = DEFAULT_OPTIONS.dup.merge(opts)
+
+      max        = opts[:max]
+      format     = opts[:format]
+      out        = File.join opts[:out]
+      listeners  = Array(opts[:notify])
+      extra_args = Array(opts[:extra_args])
+      delay      = opts[:delay]
+
+      if opts[:log]
+        listeners << LoggingListener.new
+      end
+
+      task_manager = TaskManager.new
+      features.each do |feature|
+        task_manager.add({feature: feature, format: format,out: out,extra_args: extra_args})
+      end
+
+      listeners << task_manager
+      status_server = StatusServer.new '6333'
+      worker_dir = "/tmp/jcukeforker-#{SecureRandom.hex 4}"
+      FileUtils.mkdir_p worker_dir
+
+      vnc_pool = nil
+      if vnc = opts[:vnc]
+       if vnc.kind_of?(Array)
+         vnc_pool = VncTools::ServerPool.new(max, ConfigurableVncServer.create_class(vnc))
+       elsif vnc.kind_of?(Class)
+         vnc_pool = VncTools::ServerPool.new(max, vnc)
+       else
+         vnc_pool = VncTools::ServerPool.new(max)
+       end
+      end
+
+      processes = create_processes(max, '6333', worker_dir, vnc_pool, opts[:record])
+
+      runner = Runner.new status_server, processes, worker_dir, vnc_pool, delay
+
+      listeners.each { |l|
+        status_server.add_observer l
+        runner.add_observer l
+      }
+
+      runner
+    end
+
+    def initialize(status_server, processes, worker_dir, vnc_pool, delay)
+      @status_server = status_server
+      @processes = processes
+      @worker_dir = worker_dir
+      @vnc_pool = vnc_pool
+      @delay = delay
+    end
+
+    def run
+      start
+      process
+      stop
+    rescue Interrupt
+      fire :on_run_interrupted
+      stop
+    rescue StandardError
+      fire :on_run_interrupted
+      stop
+      raise
+    end
+
+    private
+
+    def self.create_processes(max, status_path, worker_dir, vnc_pool = nil, record = false)
+      worker_file = "#{File.expand_path File.dirname(__FILE__)}/worker_script.rb"
+
+      (1..max).inject([]) do |l, i|
+        process_args = %W[ruby #{worker_file} #{status_path} #{worker_dir}/worker-#{i}]
+        if vnc_pool && record
+          record = {} unless record.kind_of? Hash
+          process_args << record.to_json
+        end
+        process = ChildProcess.build(*process_args)
+        process.environment['DISPLAY'] = vnc_pool.get.display if vnc_pool
+        l << process
+      end
+    end
+
+    def start
+      @status_server.async.run
+      fire :on_run_starting
+
+      @processes.each do |process|
+        process.start
+        sleep @delay
+      end
+    end
+
+    def process
+      @processes.each &:wait
+    end
+
+    def stop
+      @status_server.shutdown
+    ensure # catch potential second Interrupt
+      @vnc_pool.stop if @vnc_pool
+      FileUtils.rm_r @worker_dir
+      #fire :on_run_finished, @queue.has_failures?
+    end
+
+    def fire(*args)
+      changed
+      notify_observers(*args)
+    end
+
+  end # Runner
+end # CukeForker