test_bench-bootstrap 6.1.1 → 7.0.0

data/upstream-lib/test_bench_bootstrap/test_bench/session/session.rb

@@ -0,0 +1,236 @@
+module TestBenchBootstrap
+  module TestBench
+    class Session
+      Failure = Class.new(RuntimeError)
+
+      ExecutionBreak = Object.new
+
+      def telemetry
+        @telemetry ||= Telemetry::Substitute.build
+      end
+      attr_writer :telemetry
+
+      def format_backtrace
+        @format_backtrace ||= Exception::FormatBacktrace::Substitute.build
+      end
+      attr_writer :format_backtrace
+
+      def isolate
+        @isolate ||= Isolate::Substitute.build
+      end
+      attr_writer :isolate
+
+      def status
+        @status ||= Status.initial
+      end
+      attr_writer :status
+
+      def trace
+        @trace ||= Trace.new
+      end
+      attr_writer :trace
+
+      def assertion_sequence
+        @assertion_sequence ||= 0
+      end
+      attr_writer :assertion_sequence
+
+      def self.build
+        instance = new
+
+        Telemetry.configure(instance)
+        Exception::FormatBacktrace.configure(instance)
+        Isolate.configure(instance)
+
+        instance
+      end
+
+      def self.instance
+        @instance ||= build
+      end
+
+      def self.configure(receiver, session: nil, attr_name: nil)
+        session ||= instance
+        attr_name ||= :session
+
+        receiver.public_send(:"#{attr_name}=", session)
+      end
+
+      def self.establish(session)
+        @instance = session
+      end
+
+      def self.register_telemetry_sink(telemetry_sink)
+        instance.register_telemetry_sink(telemetry_sink)
+      end
+
+      def assert(value, failure_message)
+        self.assertion_sequence += 1
+
+        if not value
+          raise Failure, failure_message
+        end
+      end
+
+      def comment(text, disposition=nil)
+        record_event(Events::Commented.build(text, disposition))
+      end
+
+      def detail(text, disposition=nil)
+        record_event(Events::Detailed.build(text, disposition))
+      end
+
+      def test(title=nil, &block)
+        record_event(Events::TestStarted.build(title))
+
+        pending_test_finished_event = Events::TestFinished.build(title)
+
+        evaluate(pending_test_finished_event) do
+          previous_sequence = self.assertion_sequence
+
+          block.()
+
+          if self.assertion_sequence == previous_sequence
+            raise Failure, "Test didn't perform an assertion"
+          end
+        end
+      end
+
+      def context(title=nil, &block)
+        record_event(Events::ContextStarted.build(title))
+
+        pending_context_finished_event = Events::ContextFinished.build(title)
+
+        evaluate(pending_context_finished_event, &block)
+      end
+
+      def skip(message=nil)
+        record_event(Events::Skipped.build(message))
+      end
+
+      def execute(file_path)
+        if file_not_found?(file_path)
+          record_event(Events::FileNotFound.build(file_path))
+          return
+        end
+
+        record_event(Events::FileQueued.build(file_path))
+
+        pended_event = Events::FileExecuted.build(file_path, result)
+
+        evaluate(pended_event) do
+          isolate.(file_path) do |event_data|
+            record_event(event_data)
+          end
+        end
+      end
+
+      def file_not_found?(file_path)
+        !File.exist?(file_path)
+      end
+
+      def register_telemetry_sink(telemetry_sink)
+        telemetry.register(telemetry_sink)
+      end
+
+      def inspect(raw: nil)
+        if raw
+          return super()
+        end
+
+        telemetry_placeholder = Struct.new(:inspect).new("(not inspected)")
+
+        original_telemetry = self.telemetry
+
+        self.telemetry = telemetry_placeholder
+
+        begin
+          super()
+
+        ensure
+          self.telemetry = original_telemetry
+        end
+      end
+
+      def update(event_or_event_data)
+        case event_or_event_data
+        in Telemetry::Event => event
+
+        in Telemetry::EventData => event_data
+          event_type = event_data.type
+          event_class = Events.const_get(event_type, false)
+
+          event = Telemetry::Event::Import.(event_data, event_class)
+        end
+
+        case event
+        when Events::ContextStarted, Events::TestStarted
+          title = event.title
+
+          if not title.nil?
+            trace.push(title)
+          end
+
+        when Events::Commented, Events::Detailed
+          trace.push(event.text)
+        end
+
+        telemetry.record(event)
+
+        status.update(event)
+
+        case event
+        when Events::Commented, Events::Detailed
+          trace.pop
+
+        when Events::ContextFinished, Events::TestFinished
+          title = event.title
+
+          if not title.nil?
+            trace.pop
+          end
+        end
+      end
+      alias :record_event :update
+
+      def result(previous_status=nil)
+        status.result(previous_status)
+      end
+
+      def evaluate(pending_event, &block)
+        previous_status = status.dup
+
+        catch(ExecutionBreak) do
+          block.(self)
+        end
+
+      rescue Failure => failure
+        message = failure.message
+        record_event(Events::Failed.build(message))
+
+      rescue ::Exception => exception
+        aborted_recorded = status.error_sequence > previous_status.error_sequence
+
+        if not aborted_recorded
+          location = format_backtrace.(exception)
+
+          message = exception.detailed_message
+
+          record_event(Events::Aborted.build(message, location))
+        end
+
+        raise exception
+
+      ensure
+        result = status.result(previous_status, pending_event)
+
+        pending_event.result = result
+        record_event(pending_event)
+
+        if exception.nil?
+          return result
+        end
+      end
+    end
+  end
+end

data/upstream-lib/test_bench_bootstrap/test_bench/session/status.rb

@@ -0,0 +1,60 @@
+module TestBenchBootstrap
+  module TestBench
+    class Session
+      Status = Struct.new(:test_sequence, :failure_sequence, :error_sequence, :skip_sequence)
+
+      class Status
+        def self.initial
+          new(0, 0, 0, 0)
+        end
+
+        def result(previous_status=nil, pending_event=nil)
+          previous_status ||= Status.initial
+
+          compare_status = compare(previous_status)
+
+          if not pending_event.nil?
+            compare_status.update(pending_event)
+          end
+
+          if compare_status.error_sequence > 0
+            Result.aborted
+          elsif compare_status.failure_sequence > 0
+            Result.failed
+          elsif compare_status.skip_sequence > 0
+            Result.incomplete
+          elsif not compare_status.test_sequence > 0
+            Result.none
+          else
+            Result.passed
+          end
+        end
+
+        def update(event)
+          case event
+          when Events::TestFinished
+            self.test_sequence += 1
+          when Events::Failed
+            self.failure_sequence += 1
+          when Events::Aborted, Events::FileNotFound
+            self.error_sequence += 1
+          when Events::Skipped
+            self.skip_sequence += 1
+          end
+        end
+
+        def compare(previous_status)
+          test_sequence_difference = test_sequence - previous_status.test_sequence
+
+          failure_sequence_difference = failure_sequence - previous_status.failure_sequence
+
+          error_sequence_difference = error_sequence - previous_status.error_sequence
+
+          skip_sequence_difference = skip_sequence - previous_status.skip_sequence
+
+          Status.new(test_sequence_difference, failure_sequence_difference, error_sequence_difference, skip_sequence_difference)
+        end
+      end
+    end
+  end
+end

data/upstream-lib/test_bench_bootstrap/test_bench/session/substitute/sink.rb

@@ -0,0 +1,99 @@
+module TestBenchBootstrap
+  module TestBench
+    class Session
+      module Substitute
+        class Sink
+          include Telemetry::Sink
+
+          def trace
+            @trace ||= Trace.new
+          end
+          attr_writer :trace
+
+          def records
+            @records ||= []
+          end
+          attr_writer :records
+
+          def self.build(trace=nil)
+            instance = new
+
+            if not trace.nil?
+              instance.trace = trace
+            end
+
+            instance
+          end
+
+          def receive(event_data)
+            trace_copy = Trace.new
+
+            trace.each do |entry|
+              trace_copy.push(entry)
+            end
+
+            record = Record.new(event_data, trace_copy)
+            records.push(record)
+
+            record
+          end
+
+          def received?(event_data=nil)
+            if not event_data.nil?
+              records.any? do |record|
+                record.event_data == event_data
+              end
+            else
+              records.any?
+            end
+          end
+
+          def one_event?(event_class, *titles, **attributes)
+            event_sink = event_sink(*titles)
+            event_sink.one_event?(event_class, **attributes)
+          end
+
+          def one_event(event_class, *titles, **attributes)
+            event_sink = event_sink(*titles)
+            event_sink.one_event(event_class, **attributes)
+          end
+
+          def any_event?(event_class, *titles, **attributes)
+            event_sink = event_sink(*titles)
+            event_sink.any_event?(event_class, **attributes)
+          end
+          alias :event? :any_event?
+
+          def events(event_class, *titles, **attributes)
+            event_sink = event_sink(*titles)
+            event_sink.events(event_class, **attributes)
+          end
+
+          def event_sink(*titles)
+            event_sink = Telemetry::Substitute::Sink.new
+
+            records.each do |record|
+              if record.match?(titles)
+                event_data = record.event_data
+
+                event_sink.receive(event_data)
+              end
+            end
+
+            event_sink
+          end
+
+          Record = Struct.new(:event_data, :trace) do
+            def match?(titles)
+              if titles.any?
+                trace.match?(*titles)
+              else
+                true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/upstream-lib/test_bench_bootstrap/test_bench/session/substitute.rb

@@ -0,0 +1,154 @@
+module TestBenchBootstrap
+  module TestBench
+    class Session
+      module Substitute
+        def self.build
+          Session.build
+        end
+
+        class Session < Session
+          def sink
+            @sink ||= Sink.build(trace)
+          end
+
+          attr_accessor :record_file_not_found
+
+          def record_file_not_found!
+            self.record_file_not_found = true
+          end
+
+          def self.build
+            instance = new
+
+            sink = instance.sink
+
+            telemetry = instance.telemetry
+            telemetry.register(sink)
+
+            instance
+          end
+
+          def executed?(...)
+            isolate.executed?(...)
+          end
+
+          def file_not_found?(_file_path)
+            record_file_not_found ? true : false
+          end
+
+          def one_passed_test_finished_event?(*, **)
+            result = Result.passed
+
+            one_test_finished_event?(*, **, result:)
+          end
+          alias :one_test_passed? :one_passed_test_finished_event?
+
+          def one_passed_test_finished_event(*, **)
+            result = Result.passed
+
+            one_test_finished_event(*, **, result:)
+          end
+          alias :one_passed_test :one_passed_test_finished_event
+
+          def any_passed_test_finished_event?(*, **)
+            result = Result.passed
+
+            any_test_finished_event?(*, **, result:)
+          end
+          alias :any_test_passed? :any_passed_test_finished_event?
+          alias :test_passed? :any_test_passed?
+
+          def passed_test_finished_events(*, **)
+            result = Result.passed
+
+            test_finished_events(*, **, result:)
+          end
+          alias :passed_tests :passed_test_finished_events
+
+          def one_failed_test_finished_event?(*, **)
+            result = Result.failed
+
+            one_test_finished_event?(*, **, result:)
+          end
+          alias :one_test_failed? :one_failed_test_finished_event?
+
+          def one_failed_test_finished_event(*, **)
+            result = Result.failed
+
+            one_test_finished_event(*, **, result:)
+          end
+          alias :one_failed_test :one_failed_test_finished_event
+
+          def any_failed_test_finished_event?(*, **)
+            result = Result.failed
+
+            any_test_finished_event?(*, **, result:)
+          end
+          alias :any_test_failed? :any_failed_test_finished_event?
+          alias :test_failed? :any_test_failed?
+
+          def failed_test_finished_events(*, **)
+            result = Result.failed
+
+            test_finished_events(*, **, result:)
+          end
+          alias :failed_tests :failed_test_finished_events
+
+          [
+            Events::Failed,
+            Events::Aborted,
+            Events::Skipped,
+            Events::Commented,
+            Events::Detailed,
+            Events::TestStarted,
+            Events::TestFinished,
+            Events::ContextStarted,
+            Events::ContextFinished,
+            Events::FileQueued,
+            Events::FileExecuted,
+            Events::FileNotFound
+          ].each do |event_class|
+
+            event_name = event_class.event_name
+
+            module_eval(<<~RUBY, __FILE__, __LINE__)
+            def one_#{event_name}_event?(...)
+              one_event?(#{event_class}, ...)
+            end
+
+            def one_#{event_name}_event(...)
+              one_event(#{event_class}, ...)
+            end
+
+            def any_#{event_name}_event?(...)
+              any_event?(#{event_class}, ...)
+            end
+            alias :#{event_name}_event? :any_#{event_name}_event?
+
+            def #{event_name}_events(...)
+              events(#{event_class}, ...)
+            end
+            RUBY
+          end
+
+          def one_event?(...)
+            sink.one_event?(...)
+          end
+
+          def any_event?(...)
+            sink.any_event?(...)
+          end
+          alias :event? :any_event?
+
+          def one_event(...)
+            sink.one_event(...)
+          end
+
+          def events(...)
+            sink.events(...)
+          end
+        end
+      end
+    end
+  end
+end

data/upstream-lib/test_bench_bootstrap/test_bench/session/trace.rb

@@ -0,0 +1,53 @@
+module TestBenchBootstrap
+  module TestBench
+    class Session
+      class Trace
+        include Enumerable
+
+        def entries
+          @entries ||= []
+        end
+        attr_writer :entries
+
+        def push(entry)
+          entries.push(entry)
+        end
+
+        def pop
+          entries.pop
+        end
+
+        def match?(*context_titles, compare_text)
+          if compare_text != entries.last
+            return false
+          end
+
+          context_title_iterator = entries[0...-1].to_enum
+
+          context_titles.all? do |context_title|
+            title = context_title_iterator.next until title == context_title
+
+            true
+
+          rescue StopIteration
+            false
+          end
+        end
+
+        def each(...)
+          entries.each(...)
+        end
+
+        def join(delimiter=nil)
+          delimiter ||= self.class.join_delimiter
+
+          entries.join(delimiter)
+        end
+
+        def self.join_delimiter
+          ' :: '
+        end
+      end
+    end
+  end
+end

data/upstream-lib/test_bench_bootstrap/test_bench/session.rb

@@ -0,0 +1,22 @@
+require 'test_bench_bootstrap/test_bench/telemetry'
+
+require 'test_bench_bootstrap/test_bench/session/defaults'
+
+require 'test_bench_bootstrap/test_bench/session/result'
+
+require 'test_bench_bootstrap/test_bench/session/exception/format_backtrace'
+require 'test_bench_bootstrap/test_bench/session/exception/format_backtrace/substitute'
+
+require 'test_bench_bootstrap/test_bench/session/events'
+
+require 'test_bench_bootstrap/test_bench/session/trace'
+
+require 'test_bench_bootstrap/test_bench/session/status'
+
+require 'test_bench_bootstrap/test_bench/session/isolate'
+require 'test_bench_bootstrap/test_bench/session/isolate/substitute'
+
+require 'test_bench_bootstrap/test_bench/session/session'
+
+require 'test_bench_bootstrap/test_bench/session/substitute/sink'
+require 'test_bench_bootstrap/test_bench/session/substitute'

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/controls/event/metadata.rb

@@ -0,0 +1,72 @@
+module TestBenchBootstrap
+  module TestBench
+    class Telemetry
+      module Controls
+        module Event
+          module Metadata
+            def self.example(process_id: nil, time: nil)
+              if process_id == :none
+                process_id = nil
+              else
+                process_id ||= self.process_id
+              end
+
+              if time == :none
+                time = nil
+              else
+                time ||= self.time
+              end
+
+              metadata = Telemetry::Event::Metadata.new
+              metadata.process_id = process_id
+              metadata.time = time
+              metadata
+            end
+
+            def self.other_example
+              Other.example
+            end
+
+            def self.random
+              Random.example
+            end
+
+            def self.process_id
+              ProcessID.example
+            end
+
+            def self.time
+              Time.example
+            end
+
+            module Other
+              def self.example(process_id: nil, time: nil)
+                process_id ||= self.process_id
+                time ||= self.time
+
+                Metadata.example(process_id:, time:)
+              end
+
+              def self.process_id
+                ProcessID.other_example
+              end
+
+              def self.time
+                Time.other_example
+              end
+            end
+
+            module Random
+              def self.example(process_id: nil, time: nil)
+                process_id ||= ProcessID.random
+                time ||= Controls::Time.random
+
+                Metadata.example(process_id:, time:)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end