rspec-hermetic 0.1.0

data/lib/rspec/hermetic/probe/rails.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require_relative "../stable_value"
+require_relative "base"
+
+module RSpec
+  module Hermetic
+    module Probe
+      class Rails < Base
+        def capture(_context)
+          {}.tap do |values|
+            capture_i18n(values)
+            capture_time_zone(values)
+            capture_rails_config(values)
+            capture_rails_cache(values)
+            capture_action_mailer(values)
+            capture_active_job(values)
+            capture_action_controller(values)
+            capture_current_attributes(values)
+          end
+        end
+
+        private
+
+        def capture_i18n(values)
+          return unless Object.const_defined?(:I18n)
+
+          values["I18n.locale"] = ::I18n.locale
+          values["I18n.default_locale"] = ::I18n.default_locale
+        rescue StandardError => error
+          values["I18n"] = "#{error.class}: #{error.message}"
+        end
+
+        def capture_time_zone(values)
+          return unless Object.const_defined?(:Time) && ::Time.respond_to?(:zone)
+
+          values["Time.zone"] = StableValue.capture(::Time.zone)
+        rescue StandardError => error
+          values["Time.zone"] = "#{error.class}: #{error.message}"
+        end
+
+        def capture_rails_cache(values)
+          return unless Object.const_defined?(:Rails) && ::Rails.respond_to?(:cache)
+
+          cache = ::Rails.cache
+          values["Rails.cache.class"] = cache.class.name
+          values["Rails.cache.size"] = cache.size if cache.respond_to?(:size)
+          values["Rails.cache.keys"] = StableValue.capture(cache.keys.sort) if cache.respond_to?(:keys)
+          capture_memory_cache_data(values, cache)
+        rescue StandardError => error
+          values["Rails.cache"] = "#{error.class}: #{error.message}"
+        end
+
+        def capture_rails_config(values)
+          return unless Object.const_defined?(:Rails) &&
+                        ::Rails.respond_to?(:application) &&
+                        ::Rails.application.respond_to?(:config)
+
+          config = ::Rails.application.config
+          @configuration.rails_config_paths.each do |path|
+            values["Rails.application.config.#{path}"] = StableValue.capture(read_path(config, path))
+          rescue StandardError => error
+            values["Rails.application.config.#{path}"] = "#{error.class}: #{error.message}"
+          end
+        rescue StandardError => error
+          values["Rails.application.config"] = "#{error.class}: #{error.message}"
+        end
+
+        def capture_action_mailer(values)
+          return unless defined?(::ActionMailer::Base) && ::ActionMailer::Base.respond_to?(:deliveries)
+
+          values["ActionMailer::Base.deliveries.size"] = ::ActionMailer::Base.deliveries.size
+        rescue StandardError => error
+          values["ActionMailer::Base.deliveries"] = "#{error.class}: #{error.message}"
+        end
+
+        def capture_active_job(values)
+          return unless defined?(::ActiveJob::Base) && ::ActiveJob::Base.respond_to?(:queue_adapter)
+
+          adapter = ::ActiveJob::Base.queue_adapter
+          values["ActiveJob::Base.queue_adapter"] = adapter.class.name
+          values["ActiveJob::Base.enqueued_jobs.size"] = adapter.enqueued_jobs.size if adapter.respond_to?(:enqueued_jobs)
+        rescue StandardError => error
+          values["ActiveJob::Base"] = "#{error.class}: #{error.message}"
+        end
+
+        def capture_action_controller(values)
+          return unless defined?(::ActionController::Base)
+
+          base = ::ActionController::Base
+          if base.respond_to?(:allow_forgery_protection)
+            values["ActionController::Base.allow_forgery_protection"] = base.allow_forgery_protection
+          end
+        rescue StandardError => error
+          values["ActionController::Base"] = "#{error.class}: #{error.message}"
+        end
+
+        def capture_current_attributes(values)
+          return unless defined?(::ActiveSupport::CurrentAttributes)
+
+          ObjectSpace.each_object(Class) do |klass|
+            next unless klass < ::ActiveSupport::CurrentAttributes
+
+            values["#{klass.name}.attributes"] = StableValue.capture(klass.instance.attributes)
+          rescue StandardError => error
+            values["#{klass.name}.attributes"] = "#{error.class}: #{error.message}"
+          end
+        end
+
+        def capture_memory_cache_data(values, cache)
+          return unless cache.instance_variable_defined?(:@data)
+
+          data = cache.instance_variable_get(:@data)
+          return unless data.respond_to?(:keys)
+
+          values["Rails.cache.memory.keys"] = StableValue.capture(data.keys.map(&:to_s).sort)
+          values["Rails.cache.memory.values"] = StableValue.capture(
+            data.to_h do |key, entry|
+              [key.to_s, cache_entry_value(entry)]
+            end
+          )
+        end
+
+        def cache_entry_value(entry)
+          return entry.value if entry.respond_to?(:value)
+
+          entry
+        rescue StandardError
+          entry.inspect
+        end
+
+        def read_path(object, path)
+          path.split(".").reduce(object) do |current, segment|
+            if current.respond_to?(segment)
+              current.public_send(segment)
+            elsif current.respond_to?(:[])
+              current[segment.to_sym] || current[segment]
+            else
+              raise NoMethodError, "undefined config path segment #{segment.inspect}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/hermetic/probe/randomness.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../stable_value"
+require_relative "base"
+
+module RSpec
+  module Hermetic
+    module Probe
+      class Randomness < Base
+        def capture(_context)
+          {}.tap do |values|
+            capture_default_random(values)
+            capture_srand_seed(values) if @configuration.randomness_seed_probe
+            capture_factory_bot_sequences(values)
+          end
+        end
+
+        private
+
+        def capture_default_random(values)
+          values["Random.seed"] = ::Random.seed if ::Random.respond_to?(:seed)
+          return unless ::Random.const_defined?(:DEFAULT)
+
+          values["Random::DEFAULT"] = StableValue.capture(::Random.const_get(:DEFAULT))
+        rescue StandardError => error
+          values["Random::DEFAULT"] = "#{error.class}: #{error.message}"
+        end
+
+        def capture_srand_seed(values)
+          previous_seed = Kernel.srand
+          Kernel.srand(previous_seed)
+          values["Kernel.srand.seed"] = previous_seed
+        end
+
+        def capture_factory_bot_sequences(values)
+          return unless defined?(::FactoryBot)
+
+          sequences = factory_bot_sequences
+          return unless sequences
+
+          values["FactoryBot.sequences"] = StableValue.capture(sequences)
+          values["FactoryBot.sequence_counters"] = factory_bot_sequence_counters(sequences)
+        rescue StandardError => error
+          values["FactoryBot.sequences"] = "#{error.class}: #{error.message}"
+        end
+
+        def factory_bot_sequences
+          return ::FactoryBot.sequences if ::FactoryBot.respond_to?(:sequences)
+          if defined?(::FactoryBot::Internal) && ::FactoryBot::Internal.respond_to?(:sequences)
+            return ::FactoryBot::Internal.sequences
+          end
+
+          nil
+        end
+
+        def factory_bot_sequence_counters(sequences)
+          Array(sequences).each_with_object({}) do |sequence, counters|
+            name = if sequence.respond_to?(:name)
+                     sequence.name
+                   else
+                     sequence.object_id
+                   end
+            counters[name.to_s] = sequence_counter(sequence)
+          end
+        end
+
+        def sequence_counter(sequence)
+          return sequence.value if sequence.respond_to?(:value)
+
+          %i[@value @counter @sequence].each do |ivar|
+            return StableValue.capture(sequence.instance_variable_get(ivar)) if sequence.instance_variable_defined?(ivar)
+          end
+          StableValue.capture(sequence)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/hermetic/probe/resources.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative "../stable_value"
+require_relative "../resource_tracker"
+require_relative "base"
+
+module RSpec
+  module Hermetic
+    module Probe
+      class Resources < Base
+        def capture(_context)
+          {}.tap do |values|
+            values["threads"] = thread_snapshot
+            values["io"] = io_snapshot
+            values["child_processes"] = child_process_snapshot if @configuration.resource_process_probe
+            capture_active_record(values)
+          end
+        end
+
+        private
+
+        def thread_snapshot
+          Thread.list.filter_map do |thread|
+            next if thread == Thread.current
+            next unless thread.alive?
+
+            {
+              object_id: thread.object_id,
+              status: thread.status,
+              name: thread.name,
+              backtrace: thread.backtrace&.first,
+              origin: ResourceTracker.origin_for(thread)&.first
+            }
+          end.sort_by { |entry| entry[:object_id] }
+        end
+
+        def io_snapshot
+          ObjectSpace.each_object(IO).filter_map do |io|
+            next if io.closed?
+
+            {
+              fileno: safe_fileno(io),
+              class: io.class.name,
+              path: safe_path(io),
+              origin: ResourceTracker.origin_for(io)&.first
+            }
+          end.sort_by { |entry| [entry[:fileno].to_i, entry[:path].to_s] }
+        end
+
+        def safe_fileno(io)
+          io.fileno
+        rescue IOError
+          nil
+        end
+
+        def safe_path(io)
+          io.path if io.respond_to?(:path)
+        rescue IOError
+          nil
+        end
+
+        def capture_active_record(values)
+          return unless defined?(::ActiveRecord::Base) && ::ActiveRecord::Base.respond_to?(:connection_pool)
+
+          pool = ::ActiveRecord::Base.connection_pool
+          values["ActiveRecord::Base.connection_pool.stat"] = StableValue.capture(pool.stat) if pool.respond_to?(:stat)
+          if pool.respond_to?(:connections)
+            values["ActiveRecord::Base.connection_pool.connections.size"] = pool.connections.size
+          end
+          if ::ActiveRecord::Base.respond_to?(:connection) &&
+             ::ActiveRecord::Base.connection.respond_to?(:open_transactions)
+            values["ActiveRecord::Base.connection.open_transactions"] =
+              ::ActiveRecord::Base.connection.open_transactions
+          end
+        rescue StandardError => error
+          values["ActiveRecord::Base"] = "#{error.class}: #{error.message}"
+        end
+
+        def child_process_snapshot
+          tracked = ResourceTracker.tracked_processes.map do |entry|
+            {
+              pid: entry.fetch(:pid),
+              stat: "tracked",
+              command: entry.fetch(:command),
+              origin: entry.fetch(:origin)&.first
+            }
+          end
+
+          (tracked + ps_child_process_snapshot).uniq { |entry| entry[:pid] }.sort_by { |entry| entry[:pid].to_i }
+        end
+
+        def ps_child_process_snapshot
+          IO.popen(%w[ps -o pid= -o ppid= -o stat= -o command=], err: File::NULL, &:read).lines.filter_map do |line|
+            pid, ppid, stat, command = line.strip.split(/\s+/, 4)
+            next unless ppid.to_i == Process.pid
+            next if command&.include?("ps -o pid=")
+
+            {
+              pid: pid.to_i,
+              stat: stat,
+              command: command
+            }
+          end
+        rescue StandardError => error
+          []
+        end
+      end
+    end
+  end
+end

data/lib/rspec/hermetic/probe/ruby_runtime.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module RSpec
+  module Hermetic
+    module Probe
+      class RubyRuntime < Base
+        WARNING_CATEGORIES = %i[deprecated experimental performance].freeze
+
+        def capture(_context)
+          {
+            "$VERBOSE" => $VERBOSE,
+            "$DEBUG" => $DEBUG,
+            "Encoding.default_external" => Encoding.default_external&.name,
+            "Encoding.default_internal" => Encoding.default_internal&.name,
+            "Thread.abort_on_exception" => Thread.abort_on_exception,
+            "Thread.report_on_exception" => Thread.report_on_exception,
+            "GC.stress" => GC.stress
+          }.merge(warning_settings)
+        end
+
+        private
+
+        def warning_settings
+          return {} unless defined?(Warning)
+
+          WARNING_CATEGORIES.each_with_object({}) do |category, values|
+            values["Warning[:#{category}]"] = Warning[category]
+          rescue ArgumentError
+            values["Warning[:#{category}]"] = :unsupported
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/hermetic/probe/time.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module RSpec
+  module Hermetic
+    module Probe
+      class Time < Base
+        def capture(context)
+          {}.tap do |values|
+            capture_clock_offset(values)
+            capture_active_support_time_helpers(values, context)
+            capture_timecop(values)
+          end
+        end
+
+        private
+
+        def capture_clock_offset(values)
+          wall_time = ::Time.now.to_f
+          monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          values["clock.wall_monotonic_offset_seconds"] = (wall_time - monotonic).round
+          values["Time.now.utc_offset"] = ::Time.now.utc_offset
+        rescue StandardError => error
+          values["clock.wall_monotonic_offset_seconds"] = "#{error.class}: #{error.message}"
+        end
+
+        def capture_active_support_time_helpers(values, context)
+          return unless context
+
+          simple_stubs = context.send(:simple_stubs) if context.respond_to?(:send)
+          return unless simple_stubs&.respond_to?(:stubbed?)
+
+          values["active_support.time_helpers.stubbed"] = simple_stubs.stubbed?
+          values["active_support.time_helpers.stubbed_object_ids"] =
+            simple_stubs.instance_variable_get(:@stubs)&.map { |stub| stub.object_id } if simple_stubs.instance_variable_defined?(:@stubs)
+        rescue NameError, NoMethodError
+          nil
+        end
+
+        def capture_timecop(values)
+          return unless Object.const_defined?(:Timecop)
+
+          timecop = Object.const_get(:Timecop)
+          values["Timecop.frozen?"] = timecop.frozen? if timecop.respond_to?(:frozen?)
+          values["Timecop.travelled?"] = timecop.travelled? if timecop.respond_to?(:travelled?)
+          values["Timecop.stack"] = timecop.top_stack_item.inspect if timecop.respond_to?(:top_stack_item)
+        rescue StandardError => error
+          values["Timecop"] = "#{error.class}: #{error.message}"
+        end
+      end
+    end
+  end
+end

data/lib/rspec/hermetic/probe.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "probe/env"
+require_relative "probe/constants"
+require_relative "probe/globals"
+require_relative "probe/ruby_runtime"
+require_relative "probe/rails"
+require_relative "probe/time"
+require_relative "probe/randomness"
+require_relative "probe/resources"
+require_relative "probe/filesystem"
+
+module RSpec
+  module Hermetic
+    module Probe
+      REGISTRY = {
+        env: Env,
+        constants: Constants,
+        globals: Globals,
+        ruby_runtime: RubyRuntime,
+        rails: Rails,
+        time: Time,
+        randomness: Randomness,
+        resources: Resources,
+        filesystem: Filesystem
+      }.freeze
+
+      module_function
+
+      def build(name, configuration)
+        probe_class = REGISTRY.fetch(name.to_sym) do
+          raise Error, "unknown hermetic probe: #{name.inspect}"
+        end
+        probe_class.new(configuration)
+      end
+    end
+  end
+end

data/lib/rspec/hermetic/resource_tracker.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Hermetic
+    module ResourceTracker
+      ORIGIN_IVAR = :@rspec_hermetic_origin
+
+      module ThreadSingletonMethods
+        def new(*args, **kwargs, &block)
+          super.tap { |thread| RSpec::Hermetic::ResourceTracker.annotate(thread) }
+        end
+
+        def start(*args, **kwargs, &block)
+          super.tap { |thread| RSpec::Hermetic::ResourceTracker.annotate(thread) }
+        end
+      end
+
+      module IOSingletonMethods
+        def open(*args, **kwargs)
+          if block_given?
+            super(*args, **kwargs) do |io|
+              RSpec::Hermetic::ResourceTracker.annotate(io)
+              yield io
+            end
+          else
+            super.tap { |io| RSpec::Hermetic::ResourceTracker.annotate(io) }
+          end
+        end
+      end
+
+      module ProcessSingletonMethods
+        def spawn(*args, **kwargs)
+          super.tap do |pid|
+            RSpec::Hermetic::ResourceTracker.annotate_process(pid, args)
+          end
+        end
+      end
+
+      module_function
+
+      def install!
+        return if @installed
+
+        Thread.singleton_class.prepend(ThreadSingletonMethods)
+        IO.singleton_class.prepend(IOSingletonMethods)
+        File.singleton_class.prepend(IOSingletonMethods)
+        Process.singleton_class.prepend(ProcessSingletonMethods)
+        @installed = true
+      end
+
+      def start!
+        install!
+        @active = true
+      end
+
+      def stop!
+        @active = false
+      end
+
+      def annotate(resource)
+        return resource unless @active
+        return resource if resource.instance_variable_defined?(ORIGIN_IVAR)
+
+        resource.instance_variable_set(ORIGIN_IVAR, caller_locations(2, 8).map(&:to_s))
+        resource
+      rescue StandardError
+        resource
+      end
+
+      def annotate_process(pid, command)
+        return pid unless @active
+
+        process_origins[pid] = {
+          pid: pid,
+          command: command.flatten.map(&:to_s).join(" "),
+          origin: caller_locations(2, 8).map(&:to_s)
+        }
+        pid
+      rescue StandardError
+        pid
+      end
+
+      def origin_for(resource)
+        resource.instance_variable_get(ORIGIN_IVAR) if resource.instance_variable_defined?(ORIGIN_IVAR)
+      rescue StandardError
+        nil
+      end
+
+      def tracked_processes
+        process_origins.values.filter_map do |entry|
+          next unless process_alive?(entry.fetch(:pid))
+
+          entry
+        end
+      end
+
+      def process_origins
+        @process_origins ||= {}
+      end
+
+      def process_alive?(pid)
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH, Errno::ECHILD
+        false
+      rescue Errno::EPERM
+        true
+      end
+    end
+  end
+end