ruptr 0.1.3

data/lib/ruptr/capture_output.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'delegate'
+require 'stringio'
+
+module Ruptr
+  class CaptureOutput < Delegator
+    def initialize(real_io, tls_key)
+      @real_io = real_io
+      @tls_key = tls_key
+    end
+
+    attr_reader :real_io
+
+    if Fiber.respond_to?(:[])
+      private def tls_obj = Fiber
+    else
+      private def tls_obj = Thread.current
+    end
+
+    private def __getobj__
+      tls_obj[@tls_key] || @real_io
+    end
+
+    def capture
+      strio = StringIO.new(+'', 'w')
+      saved = tls_obj[@tls_key]
+      begin
+        tls_obj[@tls_key] = strio
+        yield
+        strio.string
+      ensure
+        tls_obj[@tls_key] = saved
+        strio.close
+      end
+    end
+
+    @mutex = Mutex.new
+    @pinned = 0
+    @fixed = false
+
+    class << self
+      def installed? = $stdout.is_a?(self) && $stderr.is_a?(self)
+
+      def install!
+        $stdout = new($stdout, :ruptr_stdout)
+        $stderr = new($stderr, :ruptr_stderr)
+      end
+
+      def uninstall!
+        $stdout = $stdout.real_io
+        $stderr = $stderr.real_io
+      end
+
+      def reset!
+        uninstall! if @fixed || @pinned.positive?
+        @fixed = false
+        @pinned = 0
+      end
+
+      def fixed_install!
+        return block_given? ? yield : nil if @fixed
+        @fixed = true
+        install!
+        return unless block_given?
+        begin
+          yield
+        ensure
+          @fixed = false
+          uninstall!
+        end
+      end
+
+      def capture_output(&)
+        unless @fixed
+          if (ractor = defined?(::Ractor) && Ractor.current != Ractor.main)
+            install! unless installed?
+          else
+            @mutex.synchronize do
+              install! unless @pinned.positive?
+              @pinned += 1
+            end
+          end
+        end
+        begin
+          stdout = stderr = nil
+          stderr = $stderr.capture { stdout = $stdout.capture(&) }
+          [stdout, stderr]
+        ensure
+          unless @fixed || ractor
+            @mutex.synchronize do
+              @pinned -= 1
+              uninstall! unless @pinned.positive?
+            end
+          end
+        end
+      end
+    end
+
+    module ForkHandler
+      # NOTE: This assumes that the child will exit and the parent unwinds.
+      def _fork = super.tap { |pid| CaptureOutput.reset! if pid.nil? || pid.zero? }
+    end
+    Process.singleton_class.prepend(ForkHandler)
+  end
+end

data/lib/ruptr/compat.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'suite'
+
+module Ruptr
+  class Compat
+    def filter_test_group(tg) = tg
+
+    def adapted_test_suite
+      filter_test_group(TestSuite.new.tap { |ts| ts.add_test_subgroup(adapted_test_group) })
+    end
+
+    def global_install! = nil
+    def global_uninstall! = nil
+    def global_monkey_patch! = nil
+    def finalize_configuration! = nil
+
+    def default_project_load_paths = []
+
+    def default_project_test_globs = []
+
+    def each_default_project_test_file(project_path, &)
+      return to_enum(__method__, project_path) unless block_given?
+      project_path.glob(default_project_test_globs, &)
+    end
+  end
+end

data/lib/ruptr/exceptions.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Ruptr
+  module AssertionErrorMixin; end
+
+  module SkippedExceptionMixin; end
+
+  module PendingPassedMixin; end
+
+  module PendingSkippedMixin; end
+
+  module SaveMessageAsReason
+    def initialize(msg = nil)
+      super
+      @reason = msg&.to_s # preserve nil as-is (unlike #message)
+    end
+
+    attr_reader :reason
+
+    def reason? = !reason.nil?
+  end
+
+  class AssertionError < StandardError
+    include AssertionErrorMixin
+  end
+
+  class SkippedException < Exception
+    include SkippedExceptionMixin
+    include SaveMessageAsReason
+  end
+
+  class PendingPassedError < StandardError
+    include PendingPassedMixin
+  end
+
+  class PendingSkippedException < SkippedException
+    include PendingSkippedMixin
+    include SaveMessageAsReason
+  end
+
+  class << self
+    attr_accessor :passthrough_exceptions
+  end
+
+  PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException, SystemExit].freeze
+  self.passthrough_exceptions = PASSTHROUGH_EXCEPTIONS
+end

data/lib/ruptr/formatter.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative 'suite'
+require_relative 'result'
+require_relative 'sink'
+require_relative 'tty_colors'
+
+module Ruptr
+  class Formatter
+    class << self
+      def class_from_env(env = ENV)
+        if (s = env['RUPTR_FORMAT'])
+          find_formatter(s.to_sym) or fail "unknown formatter: #{s}"
+        else
+          require_relative 'plain'
+          Plain
+        end
+      end
+
+      def opts_from_env(klass, env = ENV, **opts)
+        if klass.include?(Verbosity)
+          if (s = env['RUPTR_VERBOSE'])
+            opts[:verbosity] = /\A-?\d+\z/.match?(s) ? s.to_i : 1
+          end
+        end
+        opts
+      end
+
+      def from_env(output, env = ENV, **opts)
+        klass = class_from_env(env)
+        opts = opts_from_env(klass, env, **opts)
+        klass.new(output, **opts)
+      end
+
+      attr_accessor :formatter_name
+
+      def find_formatter(name)
+        traverse = proc do |c|
+          return c if c.formatter_name == name
+          c.subclasses.each(&traverse)
+        end
+        traverse.call(self)
+        nil
+      end
+    end
+
+    include Sink
+
+    private def each_exception_cause_innermost_first(ex, &)
+      return to_enum __method__, ex unless block_given?
+      each_exception_cause_innermost_first(ex.cause, &) if ex.cause
+      yield ex
+    end
+
+    module Colorizing
+      private
+
+      def initialize(*args, colorizer: TTYColors::Dummy.new, **opts)
+        super(*args, **opts)
+        @colorizer = colorizer
+      end
+
+      def colorize(s, **opts) = @colorizer.wrap(s, **opts)
+    end
+
+    module Verbosity
+      private
+
+      def initialize(*args, verbosity: 0, **opts)
+        super(*args, **opts)
+        @verbosity = verbosity
+      end
+
+      def verbose?(n = 1) = @verbosity >= n
+      def quiet?(n = 1) = @verbosity <= -n
+    end
+  end
+end

data/lib/ruptr/golden_master.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'set'
+
+module Ruptr
+  class GoldenMaster
+    GOLDEN_STORE_GOLDEN_FILENAME = 'golden'
+    GOLDEN_STORE_TRIAL_FILENAME = 'trial'
+    GOLDEN_STORE_TRIAL_PRESERVE_FILENAME = 'trial-preserve'
+
+    def initialize(state_dir,
+                   original_test_suite: nil,
+                   filtered_test_suite: original_test_suite)
+      @state_path = Pathname(state_dir)
+      @original_test_suite = original_test_suite
+      @filtered_test_suite = filtered_test_suite
+    end
+
+    attr_reader :original_test_suite, :filtered_test_suite
+
+    def test_suite = filtered_test_suite || original_test_suite
+
+    def golden_store
+      @golden_store ||= begin
+        (@state_path / "#{GOLDEN_STORE_TRIAL_PRESERVE_FILENAME}.new").open('w') do |io|
+          Marshal.dump(
+            if !@original_test_suite
+              nil # preserve everything
+            elsif @original_test_suite.equal?(@filtered_test_suite)
+              [] # preserve nothing
+            else
+              # preserve records for test elements that have been filtered out
+              @original_test_suite.each_test_element_recursive.map(&:path_identifiers) -
+                @filtered_test_suite.each_test_element_recursive.map(&:path_identifiers)
+            end,
+            io
+          )
+        end
+        GoldenMaster::Store::FS.new(
+          golden_path: @state_path / GOLDEN_STORE_GOLDEN_FILENAME,
+          trial_path: @state_path / GOLDEN_STORE_TRIAL_FILENAME,
+        ).tap(&:load_golden)
+      end
+    end
+
+    def save_trial!
+      return unless @golden_store
+      (@state_path / "#{GOLDEN_STORE_TRIAL_PRESERVE_FILENAME}.new")
+        .rename(@state_path / GOLDEN_STORE_TRIAL_PRESERVE_FILENAME)
+      @golden_store.dump_trial
+    end
+
+    def accept_trial!
+      fail "no trial data" unless (@state_path / GOLDEN_STORE_TRIAL_FILENAME).exist?
+      golden_store.accept_trial(
+        preserve: (@state_path / GOLDEN_STORE_TRIAL_PRESERVE_FILENAME).open do |io|
+                    v = Marshal.load(io)
+                    if v.nil?
+                      proc { true }
+                    else
+                      s = v.to_set
+                      proc { |(id, _)| s.include?(id) }
+                    end
+                  end
+      )
+    end
+
+    class Store
+      def initialize
+        @golden = {}
+        @trial = {}
+      end
+
+      def get_golden(k, &)
+        @golden.fetch(k, &)
+      end
+
+      def set_trial(k, v)
+        raise ArgumentError, "key already used: #{k.inspect}" if @trial.include?(k)
+        @trial.store(k, v)
+      end
+
+      def flush_trial = nil
+
+      def accept_trial(preserve: nil)
+        @golden.each_pair { |k, v| @trial[k] = v if !@trial.include?(k) && preserve.call(k) } if preserve
+        @golden = @trial
+        @trial = {}
+      end
+
+      class FS < self
+        # The same store must be usable from multiple forked process.  For each process, trial data is
+        # accumulated in @trial and appended to the @trial_tmp_path file before the process exits.
+
+        def initialize(golden_path:, trial_path:)
+          super()
+          @golden_path = golden_path
+          @golden_tmp_path = Pathname("#{golden_path}.new")
+          @trial_path = trial_path
+          @trial_tmp_path = Pathname("#{trial_path}.new")
+          @trial_tmp_path.truncate(0) if @trial_tmp_path.exist?
+        end
+
+        def load_golden
+          # NOTE: The golden file is always a single Marshal chunk.
+          @golden = @golden_path.exist? ? @golden_path.open { |io| Marshal.load(io) } : {}
+        end
+
+        def load_trial
+          # NOTE: The trial file may be made up of multiple Marshal chunks.
+          @trial = {}.tap do |h|
+            @trial_path.open { |io| h.merge!(Marshal.load(io)) until io.eof? } if @trial_path.exist?
+          end
+        end
+
+        def flush_trial
+          return if @trial.empty?
+          @trial_tmp_path.open('a') do |io|
+            # Ensuring (hopefully) that the Marshal chunk is appended with a single write(2) call.
+            io.sync = true
+            # XXX Would be better if Marshal errors were caught earlier.
+            io.write(Marshal.dump(@trial))
+          end
+          @trial.clear
+        end
+
+        def dump_trial
+          flush_trial
+          @trial_tmp_path.rename(@trial_path) if @trial_tmp_path.exist?
+        end
+
+        def accept_trial(preserve: nil)
+          load_trial
+          super
+          @golden = @golden.to_a.sort.to_h # keep golden file identical if possible
+          @golden_tmp_path.open('w') { |io| Marshal.dump(@golden, io) }
+          @golden_tmp_path.rename(@golden_path)
+        end
+      end
+    end
+  end
+end

data/lib/ruptr/instance.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Ruptr
+  module TestInstance
+    def ruptr_initialize_test_instance(context)
+      @ruptr_context = context
+    end
+
+    attr_reader :ruptr_context
+
+    def ruptr_test_element = ruptr_context.test_element
+
+    # Common methods to let multiple assertions/expectations libraries use a shared assertions
+    # counter.  The @_assertions instance variable name was chosen to be compatible with
+    # Test::Unit::Assertions::CoreAssertions which accesses it directly.
+
+    def ruptr_assertions_count
+      @_assertions || 0
+    end
+
+    def ruptr_assertions_count=(n)
+      @_assertions = n
+    end
+
+    def ruptr_internal_variable?(name)
+      name == :@_assertions || name == :@ruptr_context
+    end
+
+    def ruptr_wrap_test_instance
+      yield
+    ensure
+      ruptr_context.assertions_count += ruptr_assertions_count
+    end
+
+    def inspect = "#<#{self.class}: #{ruptr_context.test_element}>"
+  end
+end