test_bench-run 0

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

@@ -0,0 +1,180 @@
+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/controls/path.rb

@@ -0,0 +1,15 @@
+module TestBench
+  class Run
+    module Controls
+      module Path
+        def self.example
+          File.example
+        end
+
+        def self.random
+          File.random
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module TestBench
+  class Run
+    module Controls
+      ProcessID = Session::Controls::ProcessID
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module TestBench
+  class Run
+    module Controls
+      Random = Fixture::Controls::Random
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module TestBench
+  class Run
+    module Controls
+      Result = Fixture::Controls::Result
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module TestBench
+  class Run
+    module Controls
+      Time = Session::Controls::Time
+    end
+  end
+end

data/lib/test_bench/run/controls.rb

@@ -0,0 +1,26 @@
+require 'test_bench/fixture/controls'
+
+require 'test_bench/run/controls/file'
+require 'test_bench/run/controls/file/create'
+require 'test_bench/run/controls/file/pattern'
+require 'test_bench/run/controls/exception'
+require 'test_bench/run/controls/process_id'
+require 'test_bench/run/controls/random'
+require 'test_bench/run/controls/result'
+require 'test_bench/run/controls/time'
+
+require 'test_bench/run/controls/events/event_data'
+require 'test_bench/run/controls/events/file_started'
+require 'test_bench/run/controls/events/file_finished'
+require 'test_bench/run/controls/events/file_crashed'
+require 'test_bench/run/controls/events/started'
+require 'test_bench/run/controls/events/finished'
+
+require 'test_bench/run/controls/directory'
+
+require 'test_bench/run/controls/path'
+
+require 'test_bench/run/controls/event_data'
+require 'test_bench/run/controls/events/session'
+
+require 'test_bench/run/controls/executor'

data/lib/test_bench/run/events.rb

@@ -0,0 +1,12 @@
+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
+      Finished = Telemetry::Event.define(:result)
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+module TestBench
+  class Run
+    module Executor
+      class Serial
+        include Executor
+
+        attr_accessor :file_reader
+        attr_accessor :file_writer
+        attr_accessor :telemetry_reader
+        attr_accessor :telemetry_writer
+
+        def session_store
+          @session_store ||= Session::Store.new
+        end
+        attr_writer :session_store
+
+        def configure
+          Session::Store.configure(self)
+        end
+
+        def start
+          self.file_reader, self.file_writer = ::IO.pipe(flags: ::IO::DIRECT | ::IO::SYNC)
+          self.telemetry_reader, self.telemetry_writer = ::IO.pipe(flags: ::IO::DIRECT | ::IO::SYNC)
+
+          fork do
+            file_writer.close
+            telemetry_reader.close
+
+            start!
+          end
+
+          file_reader.close
+          telemetry_writer.close
+        end
+
+        def start!
+          telemetry_sink = Telemetry::Sink::File.new(telemetry_writer)
+
+          session = Session.build do |telemetry|
+            telemetry.register(telemetry_sink)
+          end
+
+          session_store.reset(session)
+
+          run_file = Run::File.build(session:)
+
+          until file_reader.eof?
+            file = file_reader.gets(chomp: true)
+
+            run_file.(file)
+          end
+
+        rescue => exception
+
+        ensure
+          if not exception.nil?
+            fork { start! }
+
+            file_reader.close
+            telemetry_writer.close
+
+            exit(false)
+          end
+        end
+        # Must refer to line containing "fork { start! }"
+        def fork_line = __LINE__ - 9
+
+        def execute(file)
+          file_writer.puts(file)
+
+          session = session_store.fetch
+
+          loop do
+            event_text = telemetry_reader.gets
+
+            event_data = Telemetry::EventData.load(event_text)
+            session.telemetry.record(event_data)
+
+            if event_data.type == :FileCrashed
+              session.record_failure
+              dump_exception_text(event_data)
+              break
+            end
+
+            if event_data.type == :FileFinished
+              break
+            end
+          end
+        end
+
+        def finish
+          file_writer.close
+          telemetry_reader.close
+
+          ::Process.waitall
+        end
+
+        def dump_exception_text(file_crashed_data)
+          error_text = file_crashed_data.data.last
+
+          error_text.gsub!(backtrace_fork_pattern, '')
+
+          STDERR.write("#{error_text}\n")
+        end
+
+        def backtrace_fork_pattern
+          @backtrace_fork_pattern ||= /^.*#{__FILE__}:#{fork_line}.*?\n/m
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,44 @@
+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/substitute.rb

@@ -0,0 +1,41 @@
+module TestBench
+  class Run
+    class File
+      module Substitute
+        def self.build
+          File.new
+        end
+
+        class File
+          def result
+            @result.nil? ? @result = true : @result
+          end
+          attr_writer :result
+          alias :set_result :result=
+
+          attr_accessor :exception
+          alias :set_exception :exception=
+          def exception? = !!exception
+
+          def files
+            @files ||= []
+          end
+
+          def call(file)
+            files << file
+
+            if exception?
+              raise exception
+            end
+
+            result
+          end
+
+          def file?(file)
+            files.include?(file)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/run/file.rb

@@ -0,0 +1,73 @@
+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 self.build(session: nil)
+        instance = new
+        Session.configure(instance, session:)
+        instance
+      end
+
+      def call(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/substitute.rb

@@ -0,0 +1,46 @@
+module TestBench
+  class Run
+    class GetFiles
+      module Substitute
+        def self.build
+          GetFiles.new
+        end
+
+        class GetFiles
+          attr_accessor :file_error
+          def file_error? = !!file_error
+
+          def files
+            @files ||= []
+          end
+          attr_writer :files
+          alias :set_files :files=
+
+          def paths
+            @paths ||= []
+          end
+
+          def file_error!
+            self.file_error = true
+          end
+
+          def call(path, *paths, &block)
+            [path, *paths].each do |path|
+              self.paths << path
+            end
+
+            if file_error?
+              raise FileError
+            end
+
+            files.each(&block)
+          end
+
+          def path?(path)
+            paths.include?(path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/run/get_files.rb

@@ -0,0 +1,72 @@
+module TestBench
+  class Run
+    class GetFiles
+      FileError = Class.new(RuntimeError)
+
+      def exclude_file_pattern
+        @exclude_file_pattern ||= Defaults.exclude_file_pattern
+      end
+      attr_writer :exclude_file_pattern
+
+      def self.build(exclude_file_pattern: nil)
+        instance = new
+
+        if not exclude_file_pattern.nil?
+          instance.exclude_file_pattern = exclude_file_pattern
+        end
+
+        instance
+      end
+
+      def self.call(path, *paths, exclude_file_pattern: nil, &block)
+        instance = build(exclude_file_pattern:)
+        instance.(path, *paths, &block)
+      end
+
+      def self.configure(receiver, exclude_file_pattern: nil, attr_name: nil)
+        attr_name ||= :get_files
+
+        instance = build(exclude_file_pattern:)
+        receiver.public_send(:"#{attr_name}=", instance)
+      end
+
+      def call(path, *paths, &block)
+        paths = [path, *paths]
+
+        exclude_file_pattern = ::File.join('**', self.exclude_file_pattern)
+
+        fnmatch_flags = ::File::FNM_PATHNAME | ::File::FNM_EXTGLOB | ::File::FNM_SYSCASE
+
+        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|
+            if ::File.fnmatch?(exclude_file_pattern, file, fnmatch_flags)
+              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_file_pattern
+          ENV.fetch('TEST_BENCH_EXCLUDE_FILE_PATTERN', '*_init.rb')
+        end
+      end
+    end
+  end
+end