zspec 1.0.0

data/lib/zspec/formatter.rb

@@ -0,0 +1,80 @@
+require "rspec/core/formatters/base_formatter"
+
+module ZSpec
+  class Formatter < ::RSpec::Core::Formatters::BaseFormatter
+    def initialize(queue:, tracker:, stdout:, message:)
+      super
+      @output_hash                = { failures: [] }
+      @failed                     = false
+      @errors_outside_of_examples = false
+      @message                    = message
+      @queue                      = queue
+      @tracker                    = tracker
+      @stdout                     = stdout
+    end
+
+    def example_failed(failure)
+      @failed = true
+      @output_hash[:failures] << format_example(failure.example)
+    end
+
+    def dump_summary(summary)
+      @duration = summary.duration
+      # only set to true if there is a failure, otherwise it will override the failures from example_failed
+      if summary.errors_outside_of_examples_count.to_i > 0
+        @failed                     = true
+        @errors_outside_of_examples = true
+      end
+      @output_hash[:summary] = format_summary(summary)
+    end
+
+    def close(_notification)
+      @queue.resolve(
+        @failed,
+        @message,
+        @output_hash.to_json,
+        @stdout.string
+      )
+      @tracker.track_runtime(@message, @duration)
+      @tracker.track_failures(@output_hash[:failures]) if @failed
+      @tracker.track_sequence(@message)
+      raise if @errors_outside_of_examples
+    end
+
+    private
+
+    def format_summary(summary)
+      {
+        duration: summary.duration,
+        load_time: summary.load_time,
+        file_path: @message,
+        example_count: summary.example_count,
+        failure_count: summary.failure_count,
+        pending_count: summary.pending_count,
+        errors_outside_of_examples_count: summary.errors_outside_of_examples_count
+      }
+    end
+
+    def format_example(example)
+      hash = {
+        id: example.id,
+        description: example.description,
+        full_description: example.full_description,
+        status: example.execution_result.status.to_s,
+        run_time: example.execution_result.run_time
+      }
+      e = example.exception
+      if e
+        hash[:exception] = {
+          class: e.class.name,
+          message: e.message,
+          backtrace: e.backtrace
+        }
+      end
+      hash
+    end
+
+    ::RSpec::Core::Formatters.register self,
+      :close, :dump_summary, :example_failed
+  end
+end

data/lib/zspec/presenter.rb

@@ -0,0 +1,172 @@
+module ZSpec
+  class Presenter
+    def initialize(queue:, tracker:, display_count:, truncate_length:, out: $stdout)
+      ::RSpec.configuration.tty = true
+      ::RSpec.configuration.color = true
+
+      @queue           = queue
+      @tracker         = tracker
+      @display_count   = display_count
+      @truncate_length = truncate_length
+      @out             = out
+
+      @failures                   = []
+      @errors_outside_of_examples = []
+      @runtimes                   = []
+
+      @example_count                    = 0
+      @failure_count                    = 0
+      @pending_count                    = 0
+      @errors_outside_of_examples_count = 0
+    end
+
+    def poll_results
+      @queue.done_queue.each do |results, stdout|
+        next if results.nil?
+        present(::JSON.parse(results), stdout)
+      end
+      print_summary
+    end
+
+    private
+
+    def present(results, stdout)
+      track_counts(results)
+      track_errors_outside_of_examples(results, stdout)
+      track_runtimes(results)
+      track_failures(results)
+    end
+
+    def print_summary
+      @out.puts ""
+      @out.puts "example_count: #{@example_count}"
+      @out.puts "failure_count: #{@failure_count}"
+      @out.puts "pending_count: #{@pending_count}"
+      @out.puts "errors_outside_of_examples_count: #{@errors_outside_of_examples_count}"
+
+      print_slow_specs
+      print_current_flaky_specs
+      print_alltime_flaky_specs
+      print_failed_specs
+      print_outside_of_examples
+
+      @out.flush
+      @failures.any? || @errors_outside_of_examples.any?
+    end
+
+    def print_outside_of_examples
+      if @errors_outside_of_examples.any?
+        @out.puts wrap("\nFIRST #{@display_count} ERRORS OUTSIDE OF EXAMPLES:", :bold)
+        @errors_outside_of_examples.take(@display_count).each do |message|
+          @out.puts wrap(truncated(message), :failure)
+        end
+      end
+    end
+
+    def print_failed_specs
+      if @failures.any?
+        @out.puts wrap("\nFIRST #{@display_count} FAILURES:", :bold)
+        @failures.take(@display_count).each_with_index do |example, index|
+          @out.puts wrap("#{example['id']}\n" \
+                    "#{example['description']} (FAILED - #{index + 1})\n" \
+                    "Exception - #{truncated(message_or_default(example))}\n" \
+                    "Backtrace - #{truncated(backtrace_or_default(example).join("\n"))}\n",
+            :failure)
+        end
+      end
+    end
+
+    def print_current_flaky_specs
+      if @tracker.current_failures.any?
+        @out.puts wrap("\nFIRST #{@display_count} FLAKY SPECS CURRENT RUN:", :bold)
+        @tracker.current_failures.take(@display_count).each do |failure|
+          @out.puts "#{failure['message']} failed #{failure['count']} times. "
+          if failure["sequence"].any?
+            @out.puts "  PREVIOUS FILES:"
+            failure["sequence"].each { |spec| @out.puts "  #{spec}" }
+          end
+        end
+      end
+    end
+
+    def print_alltime_flaky_specs
+      if @tracker.alltime_failures.any?
+        @out.puts wrap("\nFIRST #{@display_count} FLAKY SPECS LAST #{humanize(@tracker.threshold).upcase}:", :bold)
+        @tracker.alltime_failures.take(@display_count).each do |failure|
+          @out.puts "#{failure['message']} failed #{failure['count']} times. " \
+            "last failure was #{humanize(Time.now.to_i - failure['last_failure'])} ago.\n"
+        end
+      end
+    end
+
+    def print_slow_specs
+      @out.puts wrap("\n#{@display_count} SLOWEST FILES CURRENT RUN:", :bold)
+      @runtimes.sort_by { |h| h[:duration] }.reverse.take(@display_count).each do |h|
+        @out.puts "#{h[:file_path]} finished in #{format_duration(h[:duration])} " \
+          "(file took #{format_duration(h[:load_time])} to load)\n"
+      end
+    end
+
+    def track_failures(results)
+      results["failures"].each do |example|
+        @failures << example
+      end
+    end
+
+    def track_counts(results)
+      @example_count                    += results["summary"]["example_count"].to_i
+      @failure_count                    += results["summary"]["failure_count"].to_i
+      @pending_count                    += results["summary"]["pending_count"].to_i
+      @errors_outside_of_examples_count += results["summary"]["errors_outside_of_examples_count"].to_i
+    end
+
+    def track_errors_outside_of_examples(results, stdout)
+      unless stdout.nil? || stdout.empty? || results["summary"]["errors_outside_of_examples_count"].to_i == 0
+        @errors_outside_of_examples << stdout
+      end
+    end
+
+    def track_runtimes(results)
+      @runtimes << {
+        file_path: results["summary"]["file_path"],
+        duration: results["summary"]["duration"],
+        load_time: results["summary"]["load_time"]
+      }
+    end
+
+    def humanize(secs)
+      [[60, :seconds], [60, :minutes], [24, :hours], [Float::INFINITY, :days]].map { |count, name|
+        if secs > 0
+          secs, n = secs.divmod(count)
+          "#{n.to_i} #{name}" unless n.to_i == 0
+        end
+      }.compact.reverse.join(" ")
+    end
+
+    def message_or_default(example)
+      example.dig("exception", "message") || ""
+    end
+
+    def backtrace_or_default(example)
+      example.dig("exception", "backtrace") || []
+    end
+
+    def truncated(message)
+      unless message.empty?
+        if message.length < @truncate_length
+          message
+        else
+          message.slice(0..@truncate_length) + "... (truncated)"
+        end
+      end
+    end
+
+    def format_duration(duration)
+      ::RSpec::Core::Formatters::Helpers.format_duration(duration)
+    end
+
+    def wrap(message, symbol)
+      ::RSpec::Core::Formatters::ConsoleCodes.wrap(message, symbol)
+    end
+  end
+end

data/lib/zspec/queue.rb

@@ -0,0 +1,138 @@
+require "zspec/util"
+
+module ZSpec
+  class Queue
+    attr_reader :counter_name, :pending_queue_name, :processing_queue_name,
+      :done_queue_name, :metadata_hash_name, :workers_ready_key_name
+
+    include ZSpec::Util
+
+    def initialize(sink:, build_prefix:, retries:, timeout:)
+      @sink                   = sink
+      @retries                = retries.to_i
+      @timeout                = timeout.to_i
+      @counter_name           = build_prefix + ":count"
+      @pending_queue_name     = build_prefix + ":pending"
+      @processing_queue_name  = build_prefix + ":processing"
+      @done_queue_name        = build_prefix + ":done"
+      @metadata_hash_name     = build_prefix + ":metadata"
+      @workers_ready_key_name = build_prefix + ":ready"
+    end
+
+    def cleanup(expire_seconds = EXPIRE_SECONDS)
+      @sink.expire(@counter_name, expire_seconds)
+      @sink.expire(@pending_queue_name, expire_seconds)
+      @sink.expire(@processing_queue_name, expire_seconds)
+      @sink.expire(@done_queue_name, expire_seconds)
+      @sink.expire(@metadata_hash_name, expire_seconds)
+      @sink.expire(@workers_ready_key_name, expire_seconds)
+    end
+
+    def enqueue(messages)
+      messages.each do |message|
+        @sink.lpush(@pending_queue_name, message)
+        @sink.incr(@counter_name)
+      end
+      @sink.set(@workers_ready_key_name, true)
+    end
+
+    def done_queue
+      Enumerator.new do |yielder|
+        until workers_ready? && complete?
+          expire_processing
+
+          _list, message = @sink.brpop(@done_queue_name, timeout: 1)
+          if message.nil?
+            yielder << [nil, nil]
+            next
+          end
+
+          if @sink.hget(@metadata_hash_name, dedupe_key(message))
+            yielder << [nil, nil]
+            next
+          end
+
+          results = @sink.hget(@metadata_hash_name, results_key(message))
+          if results.nil?
+            yielder << [nil, nil]
+            next
+          end
+
+          stdout = @sink.hget(@metadata_hash_name, stdout_key(message))
+
+          @sink.hset(@metadata_hash_name, dedupe_key(message), true)
+          @sink.decr(@counter_name)
+
+          yielder << [results, stdout]
+        end
+      end
+    end
+
+    def pending_queue
+      Enumerator.new do |yielder|
+        until workers_ready? && complete?
+          message = @sink.brpoplpush(@pending_queue_name, @processing_queue_name, timeout: 1)
+          if message.nil?
+            yielder << nil
+            next
+          end
+          @sink.hset(@metadata_hash_name, timeout_key(message), @sink.time.first)
+          yielder << message
+        end
+      end
+    end
+
+    def resolve(failed, message, results, stdout)
+      if failed && (count = retry_count(message)) && (count < @retries)
+        retry_message(message, count)
+      else
+        resolve_message(message, results, stdout)
+      end
+    end
+
+    private
+
+    def expire_processing
+      processing.each do |message|
+        next unless expired?(message)
+
+        @sink.lrem(@processing_queue_name, 0, message)
+        @sink.rpush(@pending_queue_name, message)
+        @sink.hdel(@metadata_hash_name, timeout_key(message))
+      end
+    end
+
+    def workers_ready?
+      @sink.get(@workers_ready_key_name)
+    end
+
+    def processing
+      @sink.lrange(@processing_queue_name, 0, -1)
+    end
+
+    def complete?
+      @sink.get(@counter_name).to_i == 0
+    end
+
+    def retry_count(message)
+      @sink.hget(@metadata_hash_name, retry_key(message)).to_i
+    end
+
+    def expired?(message)
+      proccess_time = @sink.hget(@metadata_hash_name, timeout_key(message)).to_i
+      (@sink.time.first - proccess_time) > @timeout
+    end
+
+    def resolve_message(message, results, stdout)
+      @sink.hset(@metadata_hash_name, stdout_key(message), stdout)
+      @sink.hset(@metadata_hash_name, results_key(message), results)
+      @sink.lrem(@processing_queue_name, 0, message)
+      @sink.lpush(@done_queue_name, message)
+    end
+
+    def retry_message(message, count)
+      @sink.hdel(@metadata_hash_name, timeout_key(message))
+      @sink.hset(@metadata_hash_name, retry_key(message), count + 1)
+    end
+  end
+end

data/lib/zspec/scheduler.rb

@@ -0,0 +1,42 @@
+module ZSpec
+  class Scheduler
+    def initialize(queue:, tracker:)
+      @queue   = queue
+      @tracker = tracker
+    end
+
+    def schedule(args)
+      enqueue(
+        extract(args)
+        .uniq
+        .map(&method(:normalize))
+        .sort_by(&method(:runtime))
+        .reverse
+      )
+    end
+
+    private
+
+    def extract(args)
+      configuration = ::RSpec.configuration
+      ::RSpec::Core::ConfigurationOptions.new([args]).configure(configuration)
+      configuration.files_to_run
+    end
+
+    def runtimes
+      @runtimes ||= @tracker.all_runtimes
+    end
+
+    def runtime(example)
+      runtimes[example].to_i || 0
+    end
+
+    def enqueue(examples)
+      @queue.enqueue(examples)
+    end
+
+    def normalize(file)
+      file.sub("#{Dir.pwd}/", "./")
+    end
+  end
+end

data/lib/zspec/sink.rb

@@ -0,0 +1 @@
+require_relative "sink/memory_sink"

data/lib/zspec/sink/memory_sink.rb

@@ -0,0 +1,86 @@
+module ZSpec
+  module Sink
+    class MemorySink
+      def initialize(state:, expirations:)
+        @state       = state
+        @expirations = expirations
+      end
+
+      def time
+        [@state[:time]]
+      end
+
+      def expire(key, seconds)
+        @expirations[key] = seconds
+      end
+
+      def lpush(key, value)
+        (@state[key] ||= []).unshift(value)
+      end
+
+      def lrem(key, n, value)
+        (@state[key] ||= []).delete(value)
+      end
+
+      def lrange(key, start, stop)
+        (@state[key] ||= [])[start..stop]
+      end
+
+      def rpush(key, value)
+        (@state[key] ||= []).push(value)
+      end
+
+      def rpop(key)
+        (@state[key] ||= []).pop
+      end
+
+      def brpop(key, timeout: 0)
+        return [], rpop(key)
+      end
+
+      def brpoplpush(source, destination, timeout: 0)
+        _list, message = brpop(source)
+        lpush(destination, message)
+        message
+      end
+
+      def hget(key, field)
+        (@state[key] ||= {})[field]
+      end
+
+      def hgetall(key)
+        @state[key] ||= {}
+      end
+
+      def hset(key, field, value)
+        (@state[key] ||= {})[field] = value
+      end
+
+      def hdel(key, field)
+        (@state[key] ||= {}).delete(field)
+      end
+
+      def hincrby(key, field, value)
+        (@state[key] ||= {})[field] = (hget(key, field) || 0) + 1
+      end
+
+      def incr(key)
+        @state[key] ||= 0
+        @state[key] += 1
+      end
+
+      def decr(key)
+        @state[key] ||= 0
+        @state[key] -= 1
+      end
+
+      def set(key, value)
+        @state[key] = value
+      end
+
+      def get(key)
+        @state[key]
+      end
+    end
+  end
+end