rspec-tracer 0.9.3 → 1.0.0

data/lib/rspec_tracer/report_generator.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module RSpecTracer
+  class ReportGenerator
+    def initialize(reporter, cache)
+      @reporter = reporter
+      @cache = cache
+    end
+
+    def reverse_dependency_report
+      reverse_dependency = Hash.new do |examples, file_name|
+        examples[file_name] = {
+          example_count: 0,
+          examples: Hash.new(0)
+        }
+      end
+
+      @reporter.dependency.each_pair do |example_id, files|
+        next if @reporter.interrupted_examples.include?(example_id)
+
+        example_file = @reporter.all_examples[example_id][:rerun_file_name]
+
+        files.each do |file_name|
+          reverse_dependency[file_name][:example_count] += 1
+          reverse_dependency[file_name][:examples][example_file] += 1
+        end
+      end
+
+      reverse_dependency.transform_values! do |data|
+        {
+          example_count: data[:example_count],
+          examples: data[:examples].sort_by { |file_name, count| [-count, file_name] }.to_h
+        }
+      end
+
+      reverse_dependency.sort_by { |file_name, data| [-data[:example_count], file_name] }.to_h
+    end
+
+    def generate_report
+      generate_last_run_report
+      generate_examples_status_report
+
+      %i[all_files all_examples dependency examples_coverage reverse_dependency].each do |report_type|
+        starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        send("generate_#{report_type}_report")
+
+        ending = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        elapsed = RSpecTracer::TimeFormatter.format_time(ending - starting)
+
+        puts "RSpec tracer generated #{report_type.to_s.tr('_', ' ')} report (took #{elapsed})" if RSpecTracer.verbose?
+      end
+    end
+
+    private
+
+    def generate_last_run_report
+      @reporter.last_run = {
+        pid: RSpecTracer.pid,
+        actual_count: RSpec.world.example_count + @reporter.skipped_examples.count,
+        example_count: RSpec.world.example_count,
+        duplicate_examples: @reporter.duplicate_examples.sum { |_, examples| examples.count },
+        interrupted_examples: @reporter.interrupted_examples.count,
+        failed_examples: @reporter.failed_examples.count,
+        skipped_examples: @reporter.skipped_examples.count,
+        pending_examples: @reporter.pending_examples.count,
+        flaky_examples: @reporter.flaky_examples.count
+      }
+    end
+
+    def generate_examples_status_report
+      starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      generate_flaky_examples_report
+      generate_failed_examples_report
+      generate_pending_examples_report
+
+      ending = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      elapsed = RSpecTracer::TimeFormatter.format_time(ending - starting)
+
+      puts "RSpec tracer generated flaky, failed, and pending examples report (took #{elapsed})" if RSpecTracer.verbose?
+    end
+
+    def generate_flaky_examples_report
+      @reporter.possibly_flaky_examples.each do |example_id|
+        next if @reporter.example_deleted?(example_id)
+        next unless @cache.flaky_examples.include?(example_id) ||
+          @reporter.example_passed?(example_id)
+
+        @reporter.register_flaky_example(example_id)
+      end
+    end
+
+    def generate_failed_examples_report
+      @cache.failed_examples.each do |example_id|
+        next if @reporter.example_deleted?(example_id) ||
+          @reporter.all_examples.key?(example_id)
+
+        @reporter.register_failed_example(example_id)
+      end
+    end
+
+    def generate_pending_examples_report
+      @cache.pending_examples.each do |example_id|
+        next if @reporter.example_deleted?(example_id) ||
+          @reporter.all_examples.key?(example_id)
+
+        @reporter.register_pending_example(example_id)
+      end
+    end
+
+    def generate_all_files_report
+      @cache.all_files.each_pair do |file_name, data|
+        next if @reporter.all_files.key?(file_name) ||
+          @reporter.file_deleted?(file_name)
+
+        @reporter.all_files[file_name] = data
+      end
+    end
+
+    def generate_all_examples_report
+      @cache.all_examples.each_pair do |example_id, data|
+        next if @reporter.all_examples.key?(example_id) ||
+          @reporter.example_deleted?(example_id)
+
+        @reporter.all_examples[example_id] = data
+      end
+    end
+
+    def generate_dependency_report
+      @cache.dependency.each_pair do |example_id, data|
+        next if @reporter.dependency.key?(example_id) ||
+          @reporter.example_deleted?(example_id)
+
+        @reporter.dependency[example_id] = data.reject do |file_name|
+          @reporter.file_deleted?(file_name)
+        end
+      end
+
+      @reporter.dependency.transform_values!(&:to_a)
+    end
+
+    def generate_examples_coverage_report
+      @cache.cached_examples_coverage.each_pair do |example_id, data|
+        next if @reporter.examples_coverage.key?(example_id) ||
+          @reporter.example_deleted?(example_id)
+
+        @reporter.examples_coverage[example_id] = data.reject do |file_name|
+          @reporter.file_deleted?(file_name)
+        end
+      end
+    end
+
+    def generate_reverse_dependency_report
+      @reporter.reverse_dependency = reverse_dependency_report
+    end
+  end
+end

data/lib/rspec_tracer/report_merger.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RSpecTracer
+  class ReportMerger
+    attr_reader :all_examples, :duplicate_examples, :interrupted_examples,
+                :flaky_examples, :failed_examples, :pending_examples, :skipped_examples,
+                :all_files, :dependency, :reverse_dependency, :examples_coverage, :last_run
+
+    def initialize
+      @last_run = {}
+      @all_examples = {}
+      @duplicate_examples = {}
+      @interrupted_examples = Set.new
+      @flaky_examples = Set.new
+      @failed_examples = Set.new
+      @pending_examples = Set.new
+      @skipped_examples = Set.new
+      @all_files = {}
+      @dependency = Hash.new { |hash, key| hash[key] = Set.new }
+      @reverse_dependency = {}
+      @examples_coverage = {}
+    end
+
+    def merge(reports_dir)
+      reports_dir.each do |report_dir|
+        next unless File.directory?(report_dir)
+
+        merge_cache(load_cache(report_dir))
+        merge_last_run_report(File.dirname(report_dir))
+      end
+
+      @dependency.transform_values!(&:to_a)
+
+      @reverse_dependency = RSpecTracer::ReportGenerator.new(self, nil).reverse_dependency_report
+    end
+
+    private
+
+    def load_cache(cache_dir)
+      cache = RSpecTracer::Cache.new
+
+      cache.send(:load_all_examples_cache, cache_dir, discard_run_reason: false)
+      cache.send(:load_duplicate_examples_cache, cache_dir)
+      cache.send(:load_interrupted_examples_cache, cache_dir)
+      cache.send(:load_flaky_examples_cache, cache_dir)
+      cache.send(:load_failed_examples_cache, cache_dir)
+      cache.send(:load_pending_examples_cache, cache_dir)
+      cache.send(:load_skipped_examples_cache, cache_dir)
+      cache.send(:load_all_files_cache, cache_dir)
+      cache.send(:load_dependency_cache, cache_dir)
+      cache.send(:load_examples_coverage_cache, cache_dir)
+
+      cache
+    end
+
+    def merge_cache(cache)
+      @all_examples.merge!(cache.all_examples) { |_, v1, v2| v1[:run_reason] ? v1 : v2 }
+      @duplicate_examples.merge!(cache.duplicate_examples) { |_, v1, v2| v1 + v2 }
+      @interrupted_examples.merge(cache.interrupted_examples)
+      @flaky_examples.merge(cache.flaky_examples)
+      @failed_examples.merge(cache.failed_examples)
+      @pending_examples.merge(cache.pending_examples)
+      @skipped_examples.merge(cache.skipped_examples)
+      @all_files.merge!(cache.all_files)
+      @dependency.merge!(cache.dependency) { |_, v1, v2| v1.merge(v2) }
+      @examples_coverage.merge!(cache.examples_coverage) do |_, v1, v2|
+        v1.merge(v2) { |_, v3, v4| v3.merge(v4) { |_, v5, v6| v5 + v6 } }
+      end
+    end
+
+    def merge_last_run_report(cache_dir)
+      file_name = File.join(cache_dir, 'last_run.json')
+      cached_last_run = JSON.parse(File.read(file_name), symbolize_names: true)
+      cached_last_run[:pid] = [cached_last_run[:pid]]
+
+      cached_last_run.delete_if { |key, _| %i[run_id timestamp].include?(key) }
+
+      @last_run.merge!(cached_last_run) { |_, v1, v2| v1 + v2 }
+    end
+  end
+end

data/lib/rspec_tracer/report_writer.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module RSpecTracer
+  class ReportWriter
+    def initialize(report_dir, reporter)
+      @report_dir = report_dir
+      @reporter = reporter
+    end
+
+    def write_report
+      starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      @run_id = Digest::MD5.hexdigest(@reporter.all_examples.keys.sort.to_json)
+      @cache_dir = File.join(@report_dir, @run_id)
+
+      FileUtils.mkdir_p(@cache_dir)
+
+      write_all_examples_report
+      write_duplicate_examples_report
+      write_interrupted_examples_report
+      write_flaky_examples_report
+      write_failed_examples_report
+      write_pending_examples_report
+      write_skipped_examples_report
+      write_all_files_report
+      write_dependency_report
+      write_reverse_dependency_report
+      write_examples_coverage_report
+      write_last_run_report
+
+      ending = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      elapsed = RSpecTracer::TimeFormatter.format_time(ending - starting)
+
+      puts "RSpec tracer reports written to #{@cache_dir} (took #{elapsed})"
+    end
+
+    def print_duplicate_examples
+      return if @reporter.duplicate_examples.empty?
+
+      total = @reporter.duplicate_examples.sum { |_, examples| examples.count }
+
+      puts '=' * 80
+      puts '   IMPORTANT NOTICE -- RSPEC TRACER COULD NOT IDENTIFY SOME EXAMPLES UNIQUELY'
+      puts '=' * 80
+      puts "RSpec tracer could not uniquely identify the following #{total} examples:"
+
+      justify = ' ' * 2
+      nested_justify = justify * 3
+
+      @reporter.duplicate_examples.each_pair do |example_id, examples|
+        puts "#{justify}- Example ID: #{example_id} (#{examples.count} examples)"
+
+        examples.each do |example|
+          description = example[:full_description].strip
+          file_name = example[:rerun_file_name].sub(%r{^/}, '')
+          line_number = example[:rerun_line_number]
+          location = "#{file_name}:#{line_number}"
+
+          puts "#{nested_justify}* #{description} (#{location})"
+        end
+      end
+
+      puts
+    end
+
+    private
+
+    def write_all_examples_report
+      file_name = File.join(@cache_dir, 'all_examples.json')
+
+      File.write(file_name, JSON.pretty_generate(@reporter.all_examples))
+    end
+
+    def write_duplicate_examples_report
+      file_name = File.join(@cache_dir, 'duplicate_examples.json')
+
+      File.write(file_name, JSON.pretty_generate(@reporter.duplicate_examples))
+    end
+
+    def write_interrupted_examples_report
+      file_name = File.join(@cache_dir, 'interrupted_examples.json')
+
+      File.write(file_name, JSON.pretty_generate(@reporter.interrupted_examples.sort.to_a))
+    end
+
+    def write_flaky_examples_report
+      file_name = File.join(@cache_dir, 'flaky_examples.json')
+
+      File.write(file_name, JSON.pretty_generate(@reporter.flaky_examples.sort.to_a))
+    end
+
+    def write_failed_examples_report
+      file_name = File.join(@cache_dir, 'failed_examples.json')
+
+      File.write(file_name, JSON.pretty_generate(@reporter.failed_examples.sort.to_a))
+    end
+
+    def write_pending_examples_report
+      file_name = File.join(@cache_dir, 'pending_examples.json')
+
+      File.write(file_name, JSON.pretty_generate(@reporter.pending_examples.sort.to_a))
+    end
+
+    def write_skipped_examples_report
+      file_name = File.join(@cache_dir, 'skipped_examples.json')
+
+      File.write(file_name, JSON.pretty_generate(@reporter.skipped_examples.sort.to_a))
+    end
+
+    def write_all_files_report
+      file_name = File.join(@cache_dir, 'all_files.json')
+
+      File.write(file_name, JSON.pretty_generate(@reporter.all_files))
+    end
+
+    def write_dependency_report
+      file_name = File.join(@cache_dir, 'dependency.json')
+
+      File.write(file_name, JSON.pretty_generate(@reporter.dependency))
+    end
+
+    def write_reverse_dependency_report
+      file_name = File.join(@cache_dir, 'reverse_dependency.json')
+
+      File.write(file_name, JSON.pretty_generate(@reporter.reverse_dependency))
+    end
+
+    def write_examples_coverage_report
+      file_name = File.join(@cache_dir, 'examples_coverage.json')
+
+      File.write(file_name, JSON.pretty_generate(@reporter.examples_coverage))
+    end
+
+    def write_last_run_report
+      file_name = File.join(@report_dir, 'last_run.json')
+      last_run_data = @reporter.last_run.merge(run_id: @run_id, timestamp: Time.now.utc)
+
+      File.write(file_name, JSON.pretty_generate(last_run_data))
+    end
+  end
+end

data/lib/rspec_tracer/reporter.rb

@@ -4,8 +4,10 @@ module RSpecTracer
   class Reporter
     attr_reader :all_examples, :interrupted_examples, :duplicate_examples,
                 :possibly_flaky_examples, :flaky_examples, :pending_examples,
-                :all_files, :modified_files, :deleted_files, :dependency,
-                :reverse_dependency, :examples_coverage, :last_run
+                :skipped_examples, :failed_examples, :all_files, :modified_files,
+                :deleted_files, :dependency, :examples_coverage
+
+    attr_accessor :reverse_dependency, :last_run
 
     def initialize
       initialize_examples
@@ -151,92 +153,6 @@ module RSpecTracer
       @examples_coverage = examples_coverage
     end
 
-    def generate_reverse_dependency_report
-      @dependency.each_pair do |example_id, files|
-        next if @interrupted_examples.include?(example_id)
-
-        example_file = @all_examples[example_id][:rerun_file_name]
-
-        files.each do |file_name|
-          @reverse_dependency[file_name][:example_count] += 1
-          @reverse_dependency[file_name][:examples][example_file] += 1
-        end
-      end
-
-      format_reverse_dependency_report
-    end
-
-    def generate_last_run_report
-      @last_run = {
-        pid: RSpecTracer.pid,
-        actual_count: RSpec.world.example_count + @skipped_examples.count,
-        example_count: RSpec.world.example_count,
-        duplicate_examples: @duplicate_examples.sum { |_, examples| examples.count },
-        interrupted_examples: @interrupted_examples.count,
-        failed_examples: @failed_examples.count,
-        skipped_examples: @skipped_examples.count,
-        pending_examples: @pending_examples.count,
-        flaky_examples: @flaky_examples.count
-      }
-    end
-
-    def write_reports
-      starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
-      @run_id = Digest::MD5.hexdigest(@all_examples.keys.sort.to_json)
-      @cache_dir = File.join(RSpecTracer.cache_path, @run_id)
-
-      FileUtils.mkdir_p(@cache_dir)
-
-      %i[
-        all_examples
-        flaky_examples
-        failed_examples
-        pending_examples
-        all_files
-        dependency
-        reverse_dependency
-        examples_coverage
-        last_run
-      ].each { |report_type| send("write_#{report_type}_report") }
-
-      ending = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      elpased = RSpecTracer::TimeFormatter.format_time(ending - starting)
-
-      puts "RSpec tracer reports written to #{@cache_dir} (took #{elpased})"
-    end
-
-    # rubocop:disable Metrics/AbcSize
-    def print_duplicate_examples
-      return if @duplicate_examples.empty?
-
-      total = @duplicate_examples.sum { |_, examples| examples.count }
-
-      puts '=' * 80
-      puts '   IMPORTANT NOTICE -- RSPEC TRACER COULD NOT IDENTIFY SOME EXAMPLES UNIQUELY'
-      puts '=' * 80
-      puts "RSpec tracer could not uniquely identify the following #{total} examples:"
-
-      justify = ' ' * 2
-      nested_justify = justify * 3
-
-      @duplicate_examples.each_pair do |example_id, examples|
-        puts "#{justify}- Example ID: #{example_id} (#{examples.count} examples)"
-
-        examples.each do |example|
-          description = example[:full_description].strip
-          file_name = example[:rerun_file_name].sub(%r{^/}, '')
-          line_number = example[:rerun_line_number]
-          location = "#{file_name}:#{line_number}"
-
-          puts "#{nested_justify}* #{description} (#{location})"
-        end
-      end
-
-      puts
-    end
-    # rubocop:enable Metrics/AbcSize
-
     private
 
     def initialize_examples
@@ -284,75 +200,5 @@ module RSpecTracer
         status: result.status.to_s
       }
     end
-
-    def format_reverse_dependency_report
-      @reverse_dependency.transform_values! do |data|
-        {
-          example_count: data[:example_count],
-          examples: data[:examples].sort_by { |file_name, count| [-count, file_name] }.to_h
-        }
-      end
-
-      report = @reverse_dependency.sort_by do |file_name, data|
-        [-data[:example_count], file_name]
-      end
-
-      @reverse_dependency = report.to_h
-    end
-
-    def write_all_examples_report
-      file_name = File.join(@cache_dir, 'all_examples.json')
-
-      File.write(file_name, JSON.pretty_generate(@all_examples))
-    end
-
-    def write_flaky_examples_report
-      file_name = File.join(@cache_dir, 'flaky_examples.json')
-
-      File.write(file_name, JSON.pretty_generate(@flaky_examples.to_a))
-    end
-
-    def write_failed_examples_report
-      file_name = File.join(@cache_dir, 'failed_examples.json')
-
-      File.write(file_name, JSON.pretty_generate(@failed_examples.to_a))
-    end
-
-    def write_pending_examples_report
-      file_name = File.join(@cache_dir, 'pending_examples.json')
-
-      File.write(file_name, JSON.pretty_generate(@pending_examples.to_a))
-    end
-
-    def write_all_files_report
-      file_name = File.join(@cache_dir, 'all_files.json')
-
-      File.write(file_name, JSON.pretty_generate(@all_files))
-    end
-
-    def write_dependency_report
-      file_name = File.join(@cache_dir, 'dependency.json')
-
-      File.write(file_name, JSON.pretty_generate(@dependency))
-    end
-
-    def write_reverse_dependency_report
-      file_name = File.join(@cache_dir, 'reverse_dependency.json')
-
-      File.write(file_name, JSON.pretty_generate(@reverse_dependency))
-    end
-
-    def write_examples_coverage_report
-      file_name = File.join(@cache_dir, 'examples_coverage.json')
-
-      File.write(file_name, JSON.pretty_generate(@examples_coverage))
-    end
-
-    def write_last_run_report
-      file_name = File.join(RSpecTracer.cache_path, 'last_run.json')
-      last_run_data = @last_run.merge(run_id: @run_id, timestamp: Time.now.utc)
-
-      File.write(file_name, JSON.pretty_generate(last_run_data))
-    end
   end
 end

data/lib/rspec_tracer/rspec_runner.rb

@@ -2,7 +2,6 @@
 
 module RSpecTracer
   module RSpecRunner
-    # rubocop:disable Metrics/AbcSize
     def run_specs(example_groups)
       actual_count = RSpec.world.example_count
       RSpecTracer.no_examples = actual_count.zero?
@@ -23,18 +22,17 @@ module RSpecTracer
 
       current_count = RSpec.world.example_count
       ending = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      elpased = RSpecTracer::TimeFormatter.format_time(ending - starting)
+      elapsed = RSpecTracer::TimeFormatter.format_time(ending - starting)
 
       puts
       puts <<-EXAMPLES.strip.gsub(/\s+/, ' ')
         RSpec tracer is running #{current_count} examples (actual: #{actual_count},
-        skipped: #{actual_count - current_count}) (took #{elpased})
+        skipped: #{actual_count - current_count}) (took #{elapsed})
       EXAMPLES
 
       RSpecTracer.running = true
 
       super(filtered_example_groups)
     end
-    # rubocop:enable Metrics/AbcSize
   end
 end