flatware 0.2.0 → 0.3.0

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

@@ -0,0 +1,67 @@
+require 'cucumber/formatter/console'
+require 'flatware/formatters/console'
+require 'flatware/checkpoint'
+module Flatware
+  module Formatters
+    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
+end

data/lib/flatware/formatters/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/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

data/lib/flatware/poller.rb

@@ -0,0 +1,35 @@
+module Flatware
+  class Poller
+    attr_reader :sockets, :zmq_poller
+    def initialize(*sockets)
+      @sockets    = sockets
+      @zmq_poller = ZMQ::Poller.new
+      register_sockets
+    end
+
+    def each(&block)
+      while (result = zmq_poller.poll) != 0
+        raise Error, ZMQ::Util.error_string, caller if result == -1
+        for socket in zmq_poller.readables.map &find_wrapped_socket
+          yield socket
+        end
+      end
+    end
+
+    private
+
+    def find_wrapped_socket
+      ->(s) do
+        sockets.find do |socket|
+          socket.s == s
+        end
+      end
+    end
+
+    def register_sockets
+      sockets.each do |socket|
+        zmq_poller.register_readable socket.s
+      end
+    end
+  end
+end

data/lib/flatware/processor_info.rb

@@ -16,5 +16,9 @@ module Flatware
     def self.count
       new.count
     end
+
+    def self.operating_system
+      new.operating_system
+    end
   end
 end

data/lib/flatware/result.rb

@@ -1,9 +1,10 @@
 module Flatware
   class Result
-    attr_reader :progress, :steps
+    attr_reader :progress, :worker
 
-    def initialize(progress, steps=nil)
-      @progress, @steps = progress, steps || []
+    def initialize(progress)
+      @progress = progress
+      @worker   = ENV['TEST_ENV_NUMBER'].to_i
     end
 
     class << self
@@ -13,7 +14,7 @@ module Flatware
       end
 
       def status(status)
-        new Cucumber::ProgressString.format status
+        new status
       end
 
       def background(status, exception)

data/lib/flatware/scenario_decorator.rb

@@ -1,24 +1,22 @@
+require 'forwardable'
 module Flatware
   class ScenarioDecorator
-    attr_reader :status
+    extend Forwardable
+    def_delegators :scenario, :name, :file_colon_line
 
-    def initialize(scenario)
-      @scenario, @status = scenario, scenario.status
-      @scenario = scenario.scenario_outline if example_row?
-    end
-
-    def name
-      @scenario.name
-    end
+    attr_reader :status, :exception
 
-    def file_colon_line
-      @scenario.file_colon_line
+    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
+      scenario.respond_to? :scenario_outline
     end
   end
 end

data/lib/flatware/scenario_result.rb

@@ -1,10 +1,13 @@
+require 'flatware/serialized_exception'
 module Flatware
   class ScenarioResult
     attr_reader :status, :file_colon_line, :name
-    def initialize(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?
@@ -14,5 +17,20 @@ module Flatware
     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

data/lib/flatware/serialized_exception.rb

@@ -0,0 +1,20 @@
+module Flatware
+  class SerializedException
+    attr_reader :class, :message
+    attr_accessor :backtrace
+    def initialize(klass, message, backtrace)
+      @class, @message, @backtrace = serialized(klass), message, backtrace
+    end
+
+    private
+    def serialized(klass)
+      SerializedClass.new(klass.to_s)
+    end
+
+    class SerializedClass
+      attr_reader :name
+      alias to_s name
+      def initialize(name); @name = name end
+    end
+  end
+end

data/lib/flatware/sink.rb

@@ -1,5 +1,4 @@
 require 'flatware'
-require 'flatware/cucumber/formatter'
 module Flatware
   class Sink
     PORT = 'ipc://sink'
@@ -8,22 +7,28 @@ module Flatware
         client.push message
       end
 
-      def finished(job)
-        push job
-      end
-
       def start_server(*args)
         Server.new(*args).start
       end
 
+      private
+
       def client
         @client ||= Client.new
       end
     end
 
+    %w[finished started progress checkpoint].each do |message|
+      define_singleton_method message do |content|
+        push [message.to_sym, content]
+      end
+    end
+
     class Server
-      def initialize(jobs, out=$stdout, error=$stderr, fail_fast=false)
-        @jobs, @out, @error, @fail_fast = jobs, out, error, fail_fast
+      def initialize(jobs, formatter, options={})
+        @jobs, @formatter = jobs, formatter
+        options = {fail_fast: false}.merge options
+        @fail_fast = options[:fail_fast]
       end
 
       def start
@@ -33,30 +38,33 @@ module Flatware
           exit 1
         end
 
-        before_firing { listen }
+        Flatware::Fireable::bind
+        formatter.jobs jobs
+        listen
+      ensure
+        Flatware::Fireable::kill
         Flatware.close
       end
 
       def checkpoint_handler
-        @checkpoint_handler ||= CheckpointHandler.new(out, fail_fast?)
+        @checkpoint_handler ||= CheckpointHandler.new(formatter, fail_fast?)
       end
 
       def listen
         until done?
-          result = socket.recv
-          case result
-          when Result
-            print result.progress
-          when Checkpoint
-            checkpoint_handler.handle! result
-          when Job
-            completed_jobs << result
-            log "COMPLETED SCENARIO"
+          message, content = socket.recv
+          case message
+          when :checkpoint
+            checkpoint_handler.handle! content
+          when :finished
+            completed_jobs << content
+            formatter.finished content
           else
-            log "i don't know that message, bro.", result
+            formatter.send message, content
           end
         end
         checkpoint_handler.summarize
+        !checkpoint_handler.had_failures?
       rescue Error => e
         raise unless e.message == "Interrupted system call"
       end
@@ -67,41 +75,22 @@ module Flatware
         @fail_fast
       end
 
-      attr_reader :out, :jobs
-
-      def print(*args)
-        out.print *args
-      end
-
-      def puts(*args)
-        out.puts *args
-      end
+      attr_reader :jobs, :formatter
 
       def summarize_remaining
         return if remaining_work.empty?
-        puts
-        puts "The following features have not been run:"
-        for job in remaining_work
-          puts job.id
-        end
+        formatter.summarize_remaining remaining_work
       end
 
       def log(*args)
         Flatware.log *args
       end
 
-      def before_firing(&block)
-        Flatware::Fireable::bind
-        block.call
-        Flatware::Fireable::kill
-      end
-
       def completed_jobs
         @completed_jobs ||= []
       end
 
       def done?
-        log remaining_work
         remaining_work.empty? || checkpoint_handler.done?
       end