cache.rb in rspec-tracer-1.0.0

- old
+ new
@@ -1,135 +1,170 @@
 # frozen_string_literal: true
 
 module RSpecTracer
   class Cache
-    attr_reader :all_examples, :interrupted_examples, :flaky_examples, :failed_examples,
-                :pending_examples, :all_files, :dependency, :run_id
+    attr_reader :all_examples, :duplicate_examples, :interrupted_examples,
+                :flaky_examples, :failed_examples, :pending_examples, :skipped_examples,
+                :all_files, :dependency, :examples_coverage, :run_id
 
     def initialize
-      @run_id = last_run_id
-      @cache_dir = File.join(RSpecTracer.cache_path, @run_id) if @run_id
-
       @cached = false
 
       @all_examples = {}
+      @duplicate_examples = {}
       @interrupted_examples = Set.new
       @flaky_examples = Set.new
       @failed_examples = Set.new
       @pending_examples = Set.new
       @all_files = {}
       @dependency = Hash.new { |hash, key| hash[key] = Set.new }
     end
 
     def load_cache_for_run
-      return if @run_id.nil? || @cached
+      return if @cached
 
+      cache_path = RSpecTracer.cache_path
+      cache_path = File.dirname(cache_path) if RSpecTracer.parallel_tests?
+      run_id = last_run_id(cache_path)
+
+      return if run_id.nil?
+
       starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      cache_dir = File.join(cache_path, run_id)
 
-      load_all_examples_cache
-      load_flaky_examples_cache
-      load_failed_examples_cache
-      load_pending_examples_cache
-      load_all_files_cache
-      load_dependency_cache
+      load_all_examples_cache(cache_dir)
+      load_duplicate_examples_cache(cache_dir)
+      load_interrupted_examples_cache(cache_dir)
+      load_flaky_examples_cache(cache_dir)
+      load_failed_examples_cache(cache_dir)
+      load_pending_examples_cache(cache_dir)
+      load_all_files_cache(cache_dir)
+      load_dependency_cache(cache_dir)
 
       ending = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
       @cached = true
 
-      elpased = RSpecTracer::TimeFormatter.format_time(ending - starting)
+      elapsed = RSpecTracer::TimeFormatter.format_time(ending - starting)
 
-      puts "RSpec tracer loaded cache from #{@cache_dir} (took #{elpased})"
+      puts "RSpec tracer loaded cache from #{cache_dir} (took #{elapsed})"
     end
 
     def cached_examples_coverage
       return @examples_coverage if defined?(@examples_coverage)
-      return @examples_coverage = {} if @run_id.nil?
 
+      cache_path = RSpecTracer.cache_path
+      cache_path = File.dirname(cache_path) if RSpecTracer.parallel_tests?
+      run_id = last_run_id(cache_path)
+
+      return @examples_coverage = {} if run_id.nil?
+
       starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      coverage = load_examples_coverage_cache
+      cache_dir = File.join(cache_path, run_id)
+      coverage = load_examples_coverage_cache(cache_dir)
       ending = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      elpased = RSpecTracer::TimeFormatter.format_time(ending - starting)
+      elapsed = RSpecTracer::TimeFormatter.format_time(ending - starting)
 
-      puts "RSpec tracer loaded cached examples coverage (took #{elpased})" if RSpecTracer.verbose?
+      puts "RSpec tracer loaded cached examples coverage (took #{elapsed})" if RSpecTracer.verbose?
 
       coverage
     end
 
     private
 
-    def last_run_id
-      file_name = File.join(RSpecTracer.cache_path, 'last_run.json')
+    def last_run_id(cache_dir)
+      file_name = File.join(cache_dir, 'last_run.json')
 
       return unless File.file?(file_name)
 
       JSON.parse(File.read(file_name))['run_id']
     end
 
-    def load_all_examples_cache
-      file_name = File.join(@cache_dir, 'all_examples.json')
+    def load_all_examples_cache(cache_dir, discard_run_reason: true)
+      file_name = File.join(cache_dir, 'all_examples.json')
 
       return unless File.file?(file_name)
 
       @all_examples = JSON.parse(File.read(file_name)).transform_values do |examples|
         examples.transform_keys(&:to_sym)
       end
 
       @all_examples.each_value do |example|
-        if example.key?(:execution_result)
-          example[:execution_result].transform_keys!(&:to_sym)
-        else
-          @interrupted_examples << example[:example_id]
-        end
+        example[:execution_result].transform_keys!(&:to_sym) if example.key?(:execution_result)
+        example[:run_reason] = nil if discard_run_reason
+      end
+    end
 
-        example[:run_reason] = nil
+    def load_duplicate_examples_cache(cache_dir)
+      file_name = File.join(cache_dir, 'duplicate_examples.json')
+
+      return unless File.file?(file_name)
+
+      @duplicate_examples = JSON.parse(File.read(file_name)).transform_values do |examples|
+        examples.map { |example| example.transform_keys(&:to_sym) }
       end
     end
 
-    def load_flaky_examples_cache
-      file_name = File.join(@cache_dir, 'flaky_examples.json')
+    def load_interrupted_examples_cache(cache_dir)
+      file_name = File.join(cache_dir, 'interrupted_examples.json')
 
       return unless File.file?(file_name)
 
+      @interrupted_examples = JSON.parse(File.read(file_name)).to_set
+    end
+
+    def load_flaky_examples_cache(cache_dir)
+      file_name = File.join(cache_dir, 'flaky_examples.json')
+
+      return unless File.file?(file_name)
+
       @flaky_examples = JSON.parse(File.read(file_name)).to_set
     end
 
-    def load_failed_examples_cache
-      file_name = File.join(@cache_dir, 'failed_examples.json')
+    def load_failed_examples_cache(cache_dir)
+      file_name = File.join(cache_dir, 'failed_examples.json')
 
       return unless File.file?(file_name)
 
       @failed_examples = JSON.parse(File.read(file_name)).to_set
     end
 
-    def load_pending_examples_cache
-      file_name = File.join(@cache_dir, 'pending_examples.json')
+    def load_pending_examples_cache(cache_dir)
+      file_name = File.join(cache_dir, 'pending_examples.json')
 
       return unless File.file?(file_name)
 
       @pending_examples = JSON.parse(File.read(file_name)).to_set
     end
 
-    def load_all_files_cache
-      file_name = File.join(@cache_dir, 'all_files.json')
+    def load_skipped_examples_cache(cache_dir)
+      file_name = File.join(cache_dir, 'skipped_examples.json')
 
       return unless File.file?(file_name)
 
+      @skipped_examples = JSON.parse(File.read(file_name)).to_set
+    end
+
+    def load_all_files_cache(cache_dir)
+      file_name = File.join(cache_dir, 'all_files.json')
+
+      return unless File.file?(file_name)
+
       @all_files = JSON.parse(File.read(file_name)).transform_values do |files|
         files.transform_keys(&:to_sym)
       end
     end
 
-    def load_dependency_cache
-      file_name = File.join(@cache_dir, 'dependency.json')
+    def load_dependency_cache(cache_dir)
+      file_name = File.join(cache_dir, 'dependency.json')
 
       return unless File.file?(file_name)
 
       @dependency = JSON.parse(File.read(file_name)).transform_values(&:to_set)
     end
 
-    def load_examples_coverage_cache
-      file_name = File.join(@cache_dir, 'examples_coverage.json')
+    def load_examples_coverage_cache(cache_dir)
+      file_name = File.join(cache_dir, 'examples_coverage.json')
 
       return unless File.file?(file_name)
 
       @examples_coverage = JSON.parse(File.read(file_name))
     end