test_bench-run 2.1.3.1 → 3.0.0.0.pre.1

data/lib/test_bench/run/controls/file.rb

@@ -1,180 +0,0 @@
-module TestBench
-  class Run
-    module Controls
-      module File
-        def self.example(filename: nil, directory: nil, root_directory: nil)
-          filename ||= self.filename
-          directory ||= self.directory
-
-          if root_directory == :none
-            root_directory = nil
-          else
-            root_directory ||= self.root_directory
-          end
-
-          paths = []
-
-          if root_directory
-            paths << root_directory
-          end
-
-          paths << directory
-          paths << filename
-
-          ::File.join(*paths)
-        end
-
-        def self.random
-          Test.random
-        end
-
-        def self.filename
-          Name.example
-        end
-
-        def self.directory
-          Test.directory
-        end
-
-        def self.root_directory
-          '/some-root-dir'
-        end
-
-        module Random
-          def self.example(basename: nil, directory: nil, root_directory: nil)
-            basename ||= Test::Random.basename
-            directory ||= Test::Random.directory
-
-            filename = Name::Random.example(basename:)
-
-            File.example(filename:, directory:, root_directory:)
-          end
-        end
-
-        module Local
-          def self.example
-            File.example(root_directory: :none)
-          end
-
-          def self.random
-            File::Random.example(root_directory: :none)
-          end
-        end
-
-        module Test
-          extend self
-
-          def self.example(root_directory: nil)
-            filename = Name.example(basename:)
-
-            File.example(filename:, directory:, root_directory:)
-          end
-
-          def self.random
-            Random.example
-          end
-
-          def basename
-            'some_test_file'
-          end
-
-          def directory
-            'test/automated'
-          end
-
-          module Random
-            extend Test
-
-            def self.example(root_directory: nil)
-              filename = Name::Random.example(basename:)
-
-              File.example(filename:, directory:, root_directory:)
-            end
-          end
-
-          module Local
-            def self.example
-              Test.example(root_directory: :none)
-            end
-
-            def self.random
-              Test::Random.example(root_directory: :none)
-            end
-          end
-        end
-
-        module Implementation
-          extend self
-
-          def self.example(root_directory: nil)
-            filename = Name.example(basename:)
-
-            File.example(filename:, directory:, root_directory:)
-          end
-
-          def self.random
-            Random.example
-          end
-
-          def basename
-            'some_file'
-          end
-
-          def directory
-            'lib/some_directory'
-          end
-
-          module Random
-            extend Implementation
-
-            def self.example(root_directory:  nil)
-              filename = Name::Random.example(basename:)
-
-              File.example(filename:, directory:, root_directory:)
-            end
-          end
-
-          module Local
-            def self.example
-              Implementation.example(root_directory: :none)
-            end
-
-            def self.random
-              Implementation::Random.example(root_directory: :none)
-            end
-          end
-        end
-
-        module Name
-          def self.example(basename: nil)
-            basename ||= self.basename
-
-            Telemetry::Controls::File::Name.example(basename:, extension:)
-          end
-
-          def self.random
-            Random.example
-          end
-
-          def self.basename
-            'some_file'
-          end
-
-          def self.extension
-            '.rb'
-          end
-
-          module Random
-            def self.example(basename: nil)
-              basename ||= Name.basename
-
-              extension = Name.extension
-
-              Telemetry::Controls::File::Name::Random.example(basename:, extension:)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/run/events.rb

@@ -1,12 +0,0 @@
-module TestBench
-  class Run
-    module Events
-      FileStarted = Telemetry::Event.define(:file)
-      FileFinished = Telemetry::Event.define(:file, :result)
-      FileCrashed = Telemetry::Event.define(:file, :error_message, :error_text)
-
-      Started = Telemetry::Event.define(:random_seed)
-      Finished = Telemetry::Event.define(:random_seed, :result)
-    end
-  end
-end

data/lib/test_bench/run/executor/serial.rb

@@ -1,34 +0,0 @@
-module TestBench
-  class Run
-    module Executor
-      class Serial
-        include Executor
-
-        def run_file
-          @run_file ||= Run::File.build
-        end
-        attr_writer :run_file
-
-        def session_store
-          @session_store ||= Session::Store.new
-        end
-        attr_writer :session_store
-
-        def configure
-          Session::Store.configure(self)
-        end
-
-        def execute(file)
-          run_file.(file)
-
-        rescue => exception
-          session = session_store.fetch
-
-          session.record_failure
-
-          STDERR.write("#{exception.full_message}\n")
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/run/executor/substitute.rb

@@ -1,45 +0,0 @@
-module TestBench
-  class Run
-    module Executor
-      module Substitute
-        def self.build
-          Executor.new
-        end
-
-        class Executor
-          include Run::Executor
-
-          def files
-            @files ||= []
-          end
-
-          attr_accessor :started
-          def started? = !!started
-
-          attr_accessor :finished
-          def finished? = !!finished
-
-          def start
-            self.started = true
-          end
-
-          def execute(file)
-            files << file
-          end
-
-          def executed?(file=nil)
-            if not file.nil?
-              files.include?(file)
-            else
-              !files.empty?
-            end
-          end
-
-          def finish
-            self.finished = true
-          end
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/run/executor.rb

@@ -1,44 +0,0 @@
-module TestBench
-  class Run
-    module Executor
-      AbstractMethodError = Class.new(RuntimeError)
-
-      def self.included(cls)
-        cls.class_exec do
-          extend Build
-          extend Configure
-        end
-      end
-
-      def configure
-      end
-
-      def start
-      end
-
-      def execute(file)
-        raise AbstractMethodError, "Subclass didn't implement execute (File: #{file.inspect})"
-      end
-
-      def finish
-      end
-
-      module Build
-        def build
-          instance = new
-          instance.configure
-          instance
-        end
-      end
-
-      module Configure
-        def configure(receiver, attr_name: nil)
-          attr_name ||= :executor
-
-          instance = build
-          receiver.public_send(:"#{attr_name}=", instance)
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/run/file.rb

@@ -1,81 +0,0 @@
-module TestBench
-  class Run
-    class File
-      ReadFileError = Class.new(RuntimeError)
-
-      def root_directory
-        @root_directory ||= ::Dir.pwd
-      end
-      attr_writer :root_directory
-
-      def session
-        @session ||= Session::Substitute.build
-      end
-      attr_writer :session
-
-      def random
-        @random ||= Random::Substitute.build
-      end
-      attr_writer :random
-
-      def self.build(session: nil)
-        instance = new
-        Session.configure(instance, session:)
-        Random.configure(instance)
-        instance
-      end
-
-      def call(file)
-        random.reset(file)
-
-        begin
-          source = ::File.read(file)
-        rescue SystemCallError => error
-          raise ReadFileError, "Couldn't run #{file}: #{error.message.partition(' @ ').first}"
-        end
-
-        failure_sequence = session.failure_sequence
-
-        session.record_event(Events::FileStarted.new(file))
-
-        begin
-          TOPLEVEL_BINDING.eval(source, file)
-
-        rescue => exception
-          raise exception
-
-        ensure
-          if not exception.nil?
-            error_message = error_message(exception)
-            error_text = error_text(exception)
-
-            session.record_event(Events::FileCrashed.new(file, error_message, error_text))
-
-            raise exception
-          end
-        end
-
-        failed = session.failed?(failure_sequence)
-        result = !failed
-
-        session.record_event(Events::FileFinished.new(file, result))
-
-        result
-      end
-
-      def error_message(exception)
-        error_message = exception.full_message(order: :top, highlight: false).each_line(chomp: true).first
-
-        if error_message.delete_prefix!(root_directory)
-          error_message.delete_prefix!('/')
-        end
-
-        error_message
-      end
-
-      def error_text(exception)
-        exception.full_message
-      end
-    end
-  end
-end

data/lib/test_bench/run/get_files.rb

@@ -1,76 +0,0 @@
-module TestBench
-  class Run
-    class GetFiles
-      FileError = Class.new(RuntimeError)
-
-      attr_reader :exclude_patterns
-
-      def initialize(exclude_patterns)
-        @exclude_patterns = exclude_patterns
-      end
-
-      def self.build(exclude: nil)
-        exclude_patterns = exclude
-        exclude_patterns ||= Defaults.exclude_patterns
-
-        if exclude_patterns.instance_of?(String)
-          exclude_patterns = exclude_patterns.split(':')
-        end
-
-        new(exclude_patterns)
-      end
-
-      def self.call(path, *paths, exclude: nil, &block)
-        instance = build(exclude:)
-        instance.(path, *paths, &block)
-      end
-
-      def self.configure(receiver, exclude: nil, attr_name: nil)
-        attr_name ||= :get_files
-
-        instance = build(exclude:)
-        receiver.public_send(:"#{attr_name}=", instance)
-      end
-
-      def call(path, *paths, &block)
-        paths = [path, *paths]
-
-        paths.each do |path|
-          if ::File.extname(path).empty?
-            pattern = ::File.join(path, '**/*.rb')
-          else
-            pattern = path
-          end
-
-          assure_extant(path)
-
-          Dir.glob(pattern).each do |file|
-            excluded = exclude_patterns.any? do |exclude_pattern|
-              exclude_pattern = ::File.join('*', exclude_pattern)
-
-              ::File.fnmatch?(exclude_pattern, file, ::File::FNM_EXTGLOB)
-            end
-
-            if excluded
-              next
-            end
-
-            block.(file)
-          end
-        end
-      end
-
-      def assure_extant(path)
-        ::File.stat(path)
-      rescue Errno::ENOENT => enoent
-        raise FileError, enoent.message
-      end
-
-      module Defaults
-        def self.exclude_patterns
-          ENV.fetch('TEST_BENCH_EXCLUDE_FILE_PATTERN', '*_init.rb')
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/run/output/file.rb

@@ -1,135 +0,0 @@
-module TestBench
-  class Run
-    module Output
-      class File
-        Error = Class.new(RuntimeError)
-
-        include TestBench::Output
-        include Events
-
-        def session_output
-          @session_output ||= TestBench::Output::Substitute.build
-        end
-        attr_writer :session_output
-
-        def pended_events
-          @pended_events ||= {}
-        end
-        attr_writer :pended_events
-
-        def only_failure
-          @only_failure.nil? ?
-            @only_failure = Defaults.only_failure :
-            @only_failure
-        end
-        alias :only_failure? :only_failure
-        attr_writer :only_failure
-
-        def configure(...)
-          TestBench::Session::Output::Writer.configure(self, ...)
-
-          Session::Output.configure(self, writer:, attr_name: :session_output)
-        end
-
-        handle FileStarted do |file_started|
-          process_id = file_started.metadata.process_id
-
-          start(process_id)
-        end
-
-        handle FileFinished do |file_finished|
-          process_id = file_finished.metadata.process_id
-          result = file_finished.result
-          file = file_finished.file
-
-          finish(process_id, result, file)
-        end
-
-        handle FileCrashed do |file_crashed|
-          process_id = file_crashed.metadata.process_id
-          file = file_crashed.file
-
-          result = false
-
-          finish(process_id, result, file)
-        end
-
-        handle Started do
-        end
-
-        handle Finished do
-        end
-
-        def finish(process_id, result, file)
-          events = pended_events.delete(process_id)
-
-          if only_failure && result
-            return
-          end
-
-          writer.puts("Running #{file}")
-
-          writer_sequence = writer.sequence
-
-          events ||= []
-          events.each do |event_data|
-            session_output.receive(event_data)
-          end
-
-          if writer.current?(writer_sequence)
-            writer.
-              style(:faint).
-              puts("(Nothing written)")
-
-            writer.puts
-          end
-        end
-
-        def handle_event_data(event_data)
-          pend(event_data)
-        end
-
-        def pend_event(event_data)
-          process_id = event_data.process_id
-
-          if not started?(process_id)
-            start(process_id)
-          end
-
-          pended_events = self.pended_events[process_id]
-          pended_events << event_data
-        end
-        alias :pend :pend_event
-
-        def pended_event?(event_data)
-          process_id = event_data.process_id
-
-          pended_events = self.pended_events.fetch(process_id) do
-            return false
-          end
-
-          pended_events.include?(event_data)
-        end
-        alias :pended? :pended_event?
-
-        def start(process_id)
-          if started?(process_id)
-            raise Error, "Process already started (Process ID: #{process_id})"
-          end
-
-          pended_events[process_id] = []
-        end
-
-        def started?(process_id)
-          pended_events.key?(process_id)
-        end
-
-        module Defaults
-          def self.only_failure
-            ENV.fetch('TEST_BENCH_ONLY_FAILURE', 'off') == 'on'
-          end
-        end
-      end
-    end
-  end
-end