flatware-rc 1.0.0.rc

data/lib/flatware/cucumber/result.rb

@@ -0,0 +1,27 @@
+module Flatware
+  module Cucumber
+    class Result
+      attr_reader :progress, :worker
+
+      def initialize(progress)
+        @progress = progress
+        @worker   = ENV['TEST_ENV_NUMBER'].to_i
+      end
+
+      class << self
+        def step(*args)
+          step = StepResult.new *args
+          new step.progress, [step]
+        end
+
+        def status(status)
+          new status
+        end
+
+        def background(status, exception)
+          new '', [StepResult.new(status, exception)]
+        end
+      end
+    end
+  end
+end

data/lib/flatware/cucumber/runtime.rb

@@ -0,0 +1,36 @@
+require 'cucumber'
+
+module Flatware
+  module Cucumber
+    class Runtime < ::Cucumber::Runtime
+
+      attr_accessor :configuration, :loader
+      attr_reader :out, :err
+      attr_reader :visitor
+
+      def initialize(out=StringIO.new, err=out)
+        @out, @err = out, err
+        super(default_configuration)
+        load_step_definitions
+        @results = Results.new(configuration)
+      end
+
+      def default_configuration
+        config = ::Cucumber::Cli::Configuration.new
+        config.parse! []
+        config
+      end
+
+      def run(feature_files=[], options=[])
+        @loader = nil
+        options = Array(feature_files) + %w[--format Flatware::Cucumber::Formatter] + options
+
+        configure(::Cucumber::Cli::Main.new(options, out, err).configuration)
+
+        self.visitor = configuration.build_tree_walker(self)
+        visitor.visit_features(features)
+        results
+      end
+    end
+  end
+end

data/lib/flatware/cucumber/scenario_decorator.rb

@@ -0,0 +1,24 @@
+require 'forwardable'
+module Flatware
+  module Cucumber
+    class ScenarioDecorator
+      extend Forwardable
+      def_delegators :scenario, :name, :file_colon_line
+
+      attr_reader :status, :exception
+
+      def initialize(scenario)
+        @scenario, @status, @exception = scenario, scenario.status, scenario.exception
+        @scenario, @exception = scenario.scenario_outline, scenario.exception if example_row?
+      end
+
+      private
+
+      attr_reader :scenario
+
+      def example_row?
+        scenario.respond_to? :scenario_outline
+      end
+    end
+  end
+end

data/lib/flatware/cucumber/scenario_result.rb

@@ -0,0 +1,38 @@
+require 'flatware/serialized_exception'
+module Flatware
+  module Cucumber
+    class ScenarioResult
+      attr_reader :status, :file_colon_line, :name
+      def initialize(status, file_colon_line, name, e)
+        @status = status
+        @file_colon_line = file_colon_line
+        @name = name
+        @exception = SerializedException.new(e.class, e.message, e.backtrace) if e
+        @failed_outside_step = false
+      end
+
+      def passed?
+        status == :passed
+      end
+
+      def failed?
+        status == :failed
+      end
+
+      def failed_outside_step!(file_colon_line)
+        @failed_outside_step = file_colon_line
+      end
+
+      def failed_outside_step?
+        !!@failed_outside_step
+      end
+
+      def exception
+        @exception.tap do |e|
+          e.backtrace = e.backtrace.grep(Regexp.new(Dir.pwd)).map { |line| line[Dir.pwd.size..-1] }
+          e.backtrace = e.backtrace + [@failed_outside_step] if failed_outside_step?
+        end
+      end
+    end
+  end
+end

data/lib/flatware/cucumber/step_result.rb

@@ -0,0 +1,29 @@
+require 'flatware/serialized_exception'
+module Flatware
+  module Cucumber
+    class StepResult
+      attr_reader :status, :exception
+
+      def initialize(status, exception)
+        @status, @exception = status, serialized(exception)
+      end
+
+      def passed?
+        status == :passed
+      end
+
+      def failed?
+        status == :failed
+      end
+
+      def progress
+        Cucumber::ProgressString.format(status)
+      end
+
+      private
+      def serialized(e)
+        SerializedException.new(e.class, e.message, e.backtrace) if e
+      end
+    end
+  end
+end

data/lib/flatware/formatters.rb

@@ -0,0 +1,26 @@
+module Flatware
+  module Formatters
+    def self.load_by_name(runner, names)
+      formatters = names.map do |name|
+        namespace = const_get({rspec: 'RSpec', cucumber: 'Cucumber'}.fetch(runner))
+        klass = namespace.const_get name.capitalize
+        klass.new $stdout, $stderr
+      end
+      Broadcaster.new formatters
+    end
+  end
+
+  class Broadcaster
+    attr_reader :formatters
+
+    def initialize(formatters)
+      @formatters = formatters
+    end
+
+    def method_missing(name, *args)
+      formatters.each do |formatter|
+        formatter.send name, *args if formatter.respond_to? name
+      end
+    end
+  end
+end

data/lib/flatware/formatters/cucumber/console.rb

@@ -0,0 +1,48 @@
+require 'flatware/formatters/cucumber/console/summary'
+require 'cucumber/formatter/console'
+
+module Flatware::Formatters::Cucumber
+  class Console
+    #for format_string
+    include ::Cucumber::Formatter::Console
+
+    FORMATS = {
+      passed:    '.',
+      failed:    'F',
+      undefined: 'U',
+      pending:   'P',
+      skipped:   '-'
+    }
+
+    STATUSES = FORMATS.keys
+
+    attr_reader :out, :err
+
+    def initialize(stdout, stderr)
+      @out, @err = stdout, stderr
+    end
+
+    def progress(result)
+      out.print format result.progress
+    end
+
+    def summarize(checkpoints)
+      steps = checkpoints.flat_map(&:steps)
+      scenarios = checkpoints.flat_map(&:scenarios)
+      Summary.new(steps, scenarios, out).summarize
+    end
+
+    def summarize_remaining(remaining_jobs)
+      out.puts
+      out.puts "The following features have not been run:"
+      for job in remaining_jobs
+        out.puts job.id
+      end
+    end
+
+    private
+    def format(status)
+      format_string FORMATS[status], status
+    end
+  end
+end

data/lib/flatware/formatters/cucumber/console/summary.rb

@@ -0,0 +1,66 @@
+require 'cucumber/formatter/console'
+require 'flatware/formatters/cucumber/console'
+require 'flatware/cucumber/checkpoint'
+
+module Flatware::Formatters::Cucumber
+  class Console
+    class Summary
+      include ::Cucumber::Formatter::Console
+      attr_reader :io, :steps, :scenarios
+
+      def initialize(steps, scenarios=[], io=StringIO.new)
+        @io = io
+        @steps = steps
+        @scenarios = scenarios
+      end
+
+      def summarize
+        2.times { io.puts }
+        print_failures(steps, 'step')
+        print_failures(scenarios.select(&:failed_outside_step?), 'scenario')
+        print_failed_scenarios scenarios
+        print_counts 'scenario', scenarios
+        print_counts 'step', steps
+      end
+
+      private
+
+      def print_failed_scenarios(scenarios)
+        return unless scenarios.any? &with_status(:failed)
+
+        io.puts format_string "Failing Scenarios:", :failed
+        scenarios.select(&with_status(:failed)).sort_by(&:file_colon_line).each do |scenario|
+          io.puts format_string(scenario.file_colon_line, :failed) + format_string(" # Scenario: " + scenario.name, :comment)
+        end
+        io.puts
+      end
+
+      def print_failures(collection, label)
+        failures = collection.select(&with_status(:failed))
+        print_elements failures, :failed, pluralize(label, failures.size)
+      end
+
+      def print_counts(label, collection)
+        io.puts pluralize(label, collection.size) + count_summary(collection)
+      end
+
+      def pluralize(word, number)
+        "#{number} #{number == 1 ? word : word + 's'}"
+      end
+
+      def with_status(status)
+        proc {|r| r.status == status}
+      end
+
+      def count_summary(results)
+        return "" unless results.any?
+        status_counts = STATUSES.map do |status|
+          count = results.select(&with_status(status)).size
+          format_string "#{count} #{status}", status if count > 0
+        end.compact.join ", "
+
+        " (#{status_counts})"
+      end
+    end
+  end
+end

data/lib/flatware/formatters/cucumber/http.rb

@@ -0,0 +1,83 @@
+require 'net/http'
+require 'pathname'
+
+module Flatware
+  module Formatters
+    class Http
+      attr_reader :out, :client, :server_pid
+      def initialize(out, err)
+        @out = out
+        @client = Client.new
+      end
+
+      def jobs(jobs)
+        client.send_message [:jobs, jobs.map {|job| {id: job.id}}]
+      end
+
+      def started(job)
+        client.send_message [:started, job: job.id, worker: job.worker]
+      end
+
+      def finished(job)
+        client.send_message [:finished, job: job.id, worker: job.worker]
+      end
+
+      def progress(result)
+        client.send_message [:progress, status: result.progress, worker: result.worker]
+      end
+
+      def summarize(steps, scenarios)
+        client.send_message [
+          :summarize, {
+            steps: steps.map(&method(:step_as_json)),
+            scenarios: scenarios.map(&method(:scenario_as_json))
+          }
+        ]
+      end
+
+      private
+
+      def step_as_json(step)
+        { status: step.status }.tap do |h|
+          h.merge(exception: {
+            class: step.exception.class,
+            message: step.exception.message,
+            backtrace: step.exception.backtrace
+          }) if step.exception
+        end
+      end
+
+      def scenario_as_json(scenario)
+        {
+          status: scenario.status,
+          file_colon_line: scenario.file_colon_line,
+          name: scenario.name
+        }
+      end
+
+      class Client
+        attr_reader :uri
+        include Net
+
+        def initialize
+          @uri = URI ENV['FLATWARE_URL']
+        end
+
+        def send_message(message)
+          send_request uri.path, JSON.dump(message)
+        end
+
+        private
+
+        def send_request(path, body=nil)
+          req = HTTP::Post.new path
+          req.body = body
+          res = HTTP.start uri.hostname, uri.port do |http|
+            http.request req
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/flatware/formatters/rspec/console.rb

@@ -0,0 +1,33 @@
+module Flatware::Formatters::RSpec
+  class Console
+    attr_reader :formatter
+
+    def initialize(out, err)
+      ::RSpec::configuration.tty = true
+      ::RSpec::configuration.color = true
+      @formatter = ::RSpec::Core::Formatters::ProgressFormatter.new(out)
+    end
+
+    def progress(result)
+      formatter.send(message_for(result),nil)
+    end
+
+    def summarize(checkpoints)
+      result = checkpoints.reduce :+
+      if result
+        formatter.dump_failures result
+        formatter.dump_summary result.summary
+      end
+    end
+
+    private
+
+    def message_for(result)
+      {
+        passed:  :example_passed,
+        failed:  :example_failed,
+        pending: :example_pending
+      }.fetch result.progress
+    end
+  end
+end

data/lib/flatware/pids.rb

@@ -0,0 +1,25 @@
+require 'flatware/processor_info'
+module Flatware
+  extend self
+  # All the pids of all the processes called flatware on this machine
+  def pids
+    pids_command.map do |row|
+      row =~ /(\d+).*flatware/ and $1.to_i
+    end.compact
+  end
+
+  def pids_command
+    case ProcessorInfo.operating_system
+    when 'Darwin'
+      `ps -c -opid,pgid,command`
+    when 'Linux'
+      `ps -opid,pgid,command`
+    end.split("\n")[1..-1]
+  end
+
+  def pids_of_group(group_pid)
+    pids_command.map(&:split).map do |pid, pgid, _|
+      pid.to_i if pgid.to_i == group_pid
+    end.compact
+  end
+end