diff_test 0.2.0

data/lib/diff_test/integrations/rails_js/annotator.rb

@@ -0,0 +1,43 @@
+module DiffTest
+  module Integrations
+    module RailsJs
+      class Annotator
+        def self.annotate_file(file_path)
+          expanded_file_path = DiffTest::Helper.expand_path(file_path)
+          content = File.read(expanded_file_path)
+          content = annotate(content, file_path)
+          File.write(expanded_file_path, content)
+        end
+
+        def self.unannotate_file(file_path)
+          expanded_file_path = DiffTest::Helper.expand_path(file_path)
+          content = File.read(expanded_file_path)
+          content = unannotate(content)
+          File.write(expanded_file_path, content)
+        end
+
+        def self.annotate(content, file_path)
+          return content if annotated?(content)
+
+          coffee = file_path.end_with?('.coffee')
+          comment = coffee ? '#' : '//'
+          safe_method_call = coffee ? '?' : '?.'
+
+          annotation = "#{comment} Automatically added by DiffTest\n(globalThis || window)?.diffTestTrackJsFile#{safe_method_call}(\"#{file_path}\");\n#{comment} Automatically added by DiffTest\n"
+
+          annotation + content
+        end
+
+        UNANNOTATE_REGEX = /(\/\/|#) Automatically added by DiffTest.*?(\/\/|#) Automatically added by DiffTest\n/m
+        def self.unannotate(content)
+          content.gsub!(UNANNOTATE_REGEX, '')
+          content
+        end
+
+        def self.annotated?(content)
+          content.include?('diffTestTrackJsFile')
+        end
+      end
+    end
+  end
+end

data/lib/diff_test/integrations/rails_js/body_processor.rb

@@ -0,0 +1,69 @@
+module DiffTest
+  module Integrations
+    module RailsJs
+      class BodyProcessor
+        HEAD_TAG_REGEX = /<head( [^<]+)?>/
+
+        attr_reader :content_length, :new_body
+
+        def initialize(body, options)
+          @body = body
+          @options = options
+        end
+
+        def process!(env)
+          @env = env
+          @body.close if @body.respond_to?(:close)
+
+          @new_body = []
+          @body.each { |line| @new_body << line.to_s }
+
+          @content_length = 0
+          @script_added = false
+
+          @new_body = @new_body.map do |line|
+            if !@script_added && line['<head']
+              line = line.gsub(HEAD_TAG_REGEX) { |match| %(#{match}#{script}) }
+
+              @script_added = true
+            end
+
+            @content_length += line.bytesize
+            line
+          end
+        end
+
+        def script
+          <<~HTML
+            <script>
+              var owner = globalThis || window
+              owner.diffTestTrackedJsFiles = owner.diffTestTrackedJsFiles || [];
+              owner.diffTestTrackJsFile = function(file_path) {
+                const path = "/__diff_test_js_beacon";
+                const payload = JSON.stringify({ test_id: #{DiffTest::TestExecution.current.id.to_json}, file_path: file_path });
+
+                owner.diffTestTrackedJsFiles.push(file_path);
+                if (owner.navigator && owner.navigator.sendBeacon) {
+                  // Use sendBeacon in capable browsers/environments
+                  window.navigator.sendBeacon(path, payload);
+                } else {
+                  // Fallback: Use fetch from Service Worker or other Worker
+                  fetch(path, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: payload
+                  }).catch((err) => {
+                    // Handle error logging or silent fail
+                    console.error('diff_test_js_beacon_failure', err);
+                  });
+                }
+              }
+
+              owner.diffTestTrackJsFileAuto = owner.diffTestTrackJsFile;
+            </script>
+          HTML
+        end
+      end
+    end
+  end
+end

data/lib/diff_test/integrations/rails_js/integration.rb

@@ -0,0 +1,25 @@
+require_relative '../integration'
+
+module DiffTest
+  module Integrations
+    module RailsJs
+      class Integration < DiffTest::Integrations::Integration
+        def gem_name
+          'rails'
+        end
+
+        def minimum_compatible_version
+          '4.0.0'
+        end
+
+        def loaded?
+          supported? && defined?(::Rails)
+        end
+
+        def integrate
+          require_relative 'railtie'
+        end
+      end
+    end
+  end
+end

data/lib/diff_test/integrations/rails_js/js_files.rake

@@ -0,0 +1,48 @@
+require_relative 'annotator'
+
+namespace :diff_test do
+  desc 'Annotate your js files with autoTrackJsFile call'
+  task annotate: :environment do |_, args|
+    DiffTest.configuration.tracked_js_files.each do |file_path|
+      DiffTest::Integrations::RailsJs::Annotator.annotate_file(file_path)
+    end
+  end
+
+  task unannotate: :environment do |_, args|
+    DiffTest.configuration.tracked_js_files.each do |file_path|
+      DiffTest::Integrations::RailsJs::Annotator.unannotate_file(file_path)
+    end
+  end
+
+  task __auto_annotate_before_precompile: :environment do |_, args|
+    next unless DiffTest.configuration.auto_annotate_js_files?
+    next unless Rails.env.test?
+
+    Rake::Task['diff_test:annotate'].invoke
+  end
+
+  task __auto_unannotate_before_clobber: :environment do |_, args|
+    next unless DiffTest.configuration.auto_annotate_js_files?
+    next unless Rails.env.test?
+
+    Rake::Task['diff_test:unannotate'].invoke
+  end
+
+  task __auto_annotate_before_test_prepare: :environment do |_, args|
+    next unless DiffTest.configuration.auto_annotate_js_files?
+    next unless Rails.env.test?
+
+    Rake::Task['diff_test:annotate'].invoke
+  end
+end
+
+Rake::Task['assets:precompile'].enhance(['diff_test:__auto_annotate_before_precompile']) if Rake::Task.task_defined?('assets:precompile')
+Rake::Task['assets:clobber'].enhance(['diff_test:__auto_unannotate_before_clobber']) if Rake::Task.task_defined?('assets:clobber')
+
+if Rake::Task.task_defined?("test:prepare")
+  Rake::Task["test:prepare"].enhance(["diff_test:__auto_annotate_before_test_prepare"])
+elsif Rake::Task.task_defined?("spec:prepare")
+  Rake::Task["spec:prepare"].enhance(["diff_test:__auto_annotate_before_test_prepare"])
+elsif Rake::Task.task_defined?("db:test:prepare")
+  Rake::Task["db:test:prepare"].enhance(["diff_test:__auto_annotate_before_test_prepare"])
+end

data/lib/diff_test/integrations/rails_js/middleware.rb

@@ -0,0 +1,43 @@
+require_relative 'processing_skip_analyzer'
+require_relative 'body_processor'
+
+module DiffTest
+  module Integrations
+    module RailsJs
+      class Middleware
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          dup._call(env)
+        end
+
+        def _call(env)
+          path = env['PATH_INFO'] || ''
+
+          if path.include?('__diff_test_js_beacon')
+            body = env['rack.input'].read
+            json = JSON.parse(body)
+            DiffTest::Trackers::JsFile.record_by_test_id(json['test_id'], json['file_path'])
+            [204, {}, []]
+          else
+            env.delete('HTTP_IF_NONE_MATCH')
+            env.delete('HTTP_IF_MODIFIED_SINCE')
+
+            status, headers, body = result = @app.call(env)
+
+            return result if ProcessingSkipAnalyzer.skip_processing?(result, env, @options)
+
+            processor = BodyProcessor.new(body, @options)
+            processor.process!(env)
+
+            headers['content-length'] = processor.content_length.to_s
+
+            [status, headers, processor.new_body]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/diff_test/integrations/rails_js/processing_skip_analyzer.rb

@@ -0,0 +1,31 @@
+module DiffTest
+  module Integrations
+    module RailsJs
+      class ProcessingSkipAnalyzer
+        def self.skip_processing?(result, env, options)
+          new(result, env, options).skip_processing?
+        end
+
+        def initialize(result, env, options)
+          @env = env
+          @options = options
+
+          @status, @headers, @body = result
+        end
+
+        def skip_processing?
+          !html? || chunked?
+        end
+
+        def chunked?
+          @headers['Transfer-Encoding'] == 'chunked'
+        end
+
+        def html?
+          content_type = @headers['Content-Type'] || @headers['content-type']
+          content_type&.include?('text/html')
+        end
+      end
+    end
+  end
+end

data/lib/diff_test/integrations/rails_js/railtie.rb

@@ -0,0 +1,17 @@
+require_relative 'middleware'
+module DiffTest
+  module Integrations
+    module RailsJs
+      class Railtie < Rails::Railtie
+        initializer 'diff_test.middleware' do |app|
+          app.middleware.insert_before 0, DiffTest::Integrations::RailsJs::Middleware if Rails.env.test?
+        end
+
+        rake_tasks do
+          path = File.expand_path(__dir__)
+          load "#{path}/js_files.rake"
+        end
+      end
+    end
+  end
+end

data/lib/diff_test/js_version_hash_computer.rb

@@ -0,0 +1,24 @@
+require 'json'
+require_relative 'integrations/rails_js/annotator'
+
+module DiffTest
+  class JsVersionHashComputer
+    def self.compute
+      new.compute
+    end
+
+    def compute
+      string = file_paths_to_use.map do |file_path|
+        [file_path, FileHashComputer.compute_relative(file_path)]
+      end.sort_by(&:first).to_json
+
+      Digest::SHA256.hexdigest(string)
+    end
+
+    private
+
+    def file_paths_to_use
+      DiffTest.configuration.tracked_js_files
+    end
+  end
+end

data/lib/diff_test/project_version_hash_computer.rb

@@ -0,0 +1,26 @@
+require 'json'
+
+module DiffTest
+  class ProjectVersionHashComputer
+    def self.compute
+      new.compute
+    end
+
+    def compute
+      string = file_paths_to_use.map do |file_path|
+        [file_path, XXhash.xxh64_file(Helper.expand_path(file_path))]
+      end.sort_by(&:first).to_json
+
+      Digest::SHA256.hexdigest(string)
+    end
+
+    private
+
+    def file_paths_to_use
+      DiffTest.configuration.project_files -
+        DiffTest.configuration.ignored_files -
+        DiffTest.configuration.tracked_files -
+        DiffTest.configuration.tracked_js_files
+    end
+  end
+end

data/lib/diff_test/should_run_decider.rb

@@ -0,0 +1,44 @@
+module DiffTest
+  class ShouldRunDecider
+    def initialize
+      previous_compatible_test_executions = DiffTest::TestSuiteExecution.current.previous_compatible_test_executions
+      @impacted_file_path_by_id = previous_compatible_test_executions['impacted_file_path_by_id']
+      @test_suite_executions_by_id = previous_compatible_test_executions['test_suite_executions_by_id']
+      @test_executions_by_test = previous_compatible_test_executions['test_executions_by_test']
+    end
+
+    def should_run?(test_id, system_test:)
+      previous_test_executions = @test_executions_by_test[test_id] || []
+
+      # If there are any previous test executions run whose impacted files are the same as now
+      #  Assume its safe to skip
+      has_previous_execution_with_no_impacted_changes = previous_test_executions.any? do |previous_test_execution|
+        hashes_match = previous_test_execution['test_execution_impacted_files'].all? do |test_execution_impacted_file|
+          impacted_file_id = test_execution_impacted_file['impacted_file_id'].to_s
+          file_hash = test_execution_impacted_file['file_hash']
+          impacted_file_path = @impacted_file_path_by_id[impacted_file_id]
+
+          DiffTest::FileHashComputer.compute_relative(impacted_file_path) == file_hash
+        end
+        next false unless hashes_match
+        next true unless system_test
+
+        test_suite_execution = @test_suite_executions_by_id[previous_test_execution['test_suite_execution_id'].to_s]
+        next true if test_suite_execution['all_js_files_annotated']
+        next true if test_suite_execution['js_version_hash'] == DiffTest::TestSuiteExecution.current.js_version_hash
+
+        false
+      end
+
+      !has_previous_execution_with_no_impacted_changes
+    end
+
+    def self.current
+      @current ||= DiffTest::ShouldRunDecider.new
+    end
+
+    def self.should_run?(test_id, system_test:)
+      current.should_run?(test_id, system_test: system_test)
+    end
+  end
+end

data/lib/diff_test/test_execution.rb

@@ -0,0 +1,92 @@
+require_relative 'should_run_decider'
+
+module DiffTest
+  class TestExecution
+    attr_reader :impacted_file_tracker
+
+    def initialize(test_file_path:, test_name:)
+      @test_file_path = test_file_path
+      @test_name = test_name
+      @result = :queued
+      @started_at = Time.now
+      @stopped_at = Time.now
+      @impacted_file_tracker  = DiffTest::ImpactedFileTracker.new
+      self.class.set(id, self)
+    end
+
+    def should_run?
+      return @should_run unless @should_run.nil?
+      @should_run = DiffTest::ShouldRunDecider.should_run?(id, system_test: system_test?)
+    end
+
+    def save_payload
+      {
+        test: id,
+        result: @result,
+        runtime_ms: runtime_ms,
+        impacted_files: @impacted_file_tracker.save_payload,
+      }
+    end
+
+    def id
+      @id ||= DiffTest::Helper.test_id(@test_file_path, @test_name)
+    end
+
+    def start
+      @impacted_file_tracker.start
+      @started_at = Time.now
+    end
+
+    def stop
+      @impacted_file_tracker.stop
+      @stopped_at = Time.now
+      finish
+    end
+
+    def finish
+      DiffTest::TestSuiteExecution.current.record_test_execution(self)
+    end
+
+    def not_run!
+      @result = :not_run
+    end
+
+    def skipped!
+      @result = :skipped
+    end
+
+    def passed!
+      @result = :passed
+    end
+
+    def failed!
+      @result = :failed
+    end
+
+    def runtime_ms
+      return 0 if @stopped_at.nil? || @started_at.nil?
+      (@stopped_at - @started_at) * 1000
+    end
+
+    def system_test?
+      DiffTest.configuration.system_test_paths.include?(@test_file_path)
+    end
+
+    def self.set(test_id, instance)
+      @by_id ||= {}
+      @by_id[test_id] = instance
+    end
+
+    def self.get(test_id)
+      @by_id[test_id]
+    end
+
+    def self.current
+      @current
+    end
+
+    def self.current=(instance)
+      @current = instance
+    end
+  end
+end

data/lib/diff_test/test_suite_execution.rb

@@ -0,0 +1,114 @@
+require_relative 'project_version_hash_computer'
+require_relative 'js_version_hash_computer'
+
+module DiffTest
+  class TestSuiteExecution
+    def initialize(tests:)
+      @tests = tests.compact
+      @test_executions = []
+
+      find_or_create_on_server
+    end
+
+    def previous_compatible_test_executions
+      DiffTest::ApiClient.post("/test_suite_executions/#{id}/previous_compatible_test_executions", body: { tests: @tests })
+    end
+
+    def ensure_application_eager_loaded!
+      return if @eager_loaded
+      @eager_loaded = true
+      ::Rails.application.eager_load! if defined?(::Rails)
+    end
+
+
+    def record_test_execution(test_execution)
+      @test_executions << test_execution
+    end
+
+    def run?(test_file_path, test_name)
+      should_run_decider.run?(test_file_path, test_name)
+    end
+
+    def save
+      save_test_execution_results_on_server
+    end
+
+   def js_version_hash
+      @js_version_hash ||= DiffTest::JsVersionHashComputer.compute
+    end
+
+    def self.current
+      @current
+    end
+
+    def self.current=(value)
+      @current = value
+    end
+
+    def self.find_or_create(tests)
+      self.current ||= new(tests:)
+    end
+
+    private
+
+    def id
+      @id || raise('Not created')
+    end
+
+    def find_or_create_on_server
+      response = DiffTest::ApiClient.post("/test_suite_executions", body: payload)
+      raise "Failed to create test suite execution: #{response.inspect}" unless response.success?
+      @id = response['id']
+    end
+
+    def save_test_execution_results_on_server
+      raise "Expected to have at least one test execution" if @test_executions.empty?
+      response = DiffTest::ApiClient.post("/test_suite_executions/#{id}/test_executions/bulk_create", body: { test_executions: @test_executions.map(&:save_payload) })
+    end
+
+    def payload
+      {
+        key: key,
+        project_version_hash: project_version_hash,
+        js_version_hash: js_version_hash,
+        all_js_files_annotated: all_js_files_annotated?,
+        rev_sha: rev_sha,
+        commit_title: commit_title,
+        branch_name: branch_name,
+        ci_platform: DiffTest.configuration.ci_platform,
+        meta: meta,
+      }
+    end
+
+    def key
+      ENV['CIRCLE_WORKFLOW_ID'] || SecureRandom.hex(48) || rev_sha
+    end
+
+    def project_version_hash
+      @project_version_hash ||= DiffTest::ProjectVersionHashComputer.compute
+    end
+
+    def all_js_files_annotated?
+      @all_js_files_annotated ||= DiffTest.configuration.tracked_js_files.all? do |file_path|
+        file_path = DiffTest::Helper.expand_path(file_path)
+        DiffTest::Integrations::RailsJs::Annotator.annotated?(File.read(file_path))
+      end
+    end
+
+    def rev_sha
+      @rev_sha ||= `git rev-parse HEAD`.strip
+    end
+
+    def commit_title
+      @commit_title ||= `git log -1 --pretty=%B`.strip
+    end
+
+    def branch_name
+      @branch_name ||= `git rev-parse --abbrev-ref HEAD`.strip
+    end
+
+    def meta
+      {}
+    end
+  end
+end

data/lib/diff_test/trackers/base.rb

@@ -0,0 +1,23 @@
+module DiffTest
+  module Trackers
+    class Base
+      attr_reader :impacted_files
+
+      def initialize
+        @impacted_files = Set.new
+      end
+
+      def enable
+        raise NotImplementedError
+      end
+
+      def disable
+        raise NotImplementedError
+      end
+
+      def record(path)
+        @impacted_files << path
+      end
+    end
+  end
+end

data/lib/diff_test/trackers/js_file.rb

@@ -0,0 +1,7 @@
+require_relative 'singleton_base'
+module DiffTest
+  module Trackers
+    class JsFile < DiffTest::Trackers::SingletonBase
+    end
+  end
+end

data/lib/diff_test/trackers/ruby_file.rb

@@ -0,0 +1,50 @@
+require_relative 'base'
+module DiffTest
+  module Trackers
+    class RubyFile < DiffTest::Trackers::Base
+      @@location_by_constant = {}
+
+      def enable
+        @seen_constants = Set.new
+        @tracepoint = TracePoint.new(:call, :c_call, :b_call) do |event|
+          if DiffTest::Helper.file_in_project?(event.path)
+            record(DiffTest::Helper.relative_path_from_project_root(event.path))
+          end
+
+          constant = event.defined_class
+          constant = event.self if constant == Class && event.method_id == :new
+
+          unless @seen_constants.include?(constant)
+            @seen_constants.add(constant)
+            constant = constant.attached_object if constant&.singleton_class?
+
+            path = @@location_by_constant[constant]
+
+            if path.nil?
+              if constant
+                path = begin
+                  DiffTest::Helper.const_source_path(constant.name)
+                rescue StandardError
+                  nil
+                end
+              end
+              path = false if !path || !DiffTest::Helper.file_in_project?(path)
+              path = DiffTest::Helper.relative_path_from_project_root(path) if path
+              @@location_by_constant[constant] = path
+            end
+
+            record(path) if path
+          end
+        end
+
+        @tracepoint.enable
+      end
+
+      def disable
+        @tracepoint.disable
+        @tracepoint = nil
+        @seen_constants = nil
+      end
+    end
+  end
+end