test_bench-isolated 0 → 2.0.0.1

data/lib/test_bench_isolated/test_bench/run/get_files/substitute.rb

@@ -0,0 +1,48 @@
+module TestBenchIsolated
+  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
+end

data/lib/test_bench_isolated/test_bench/run/get_files.rb

@@ -0,0 +1,78 @@
+module TestBenchIsolated
+  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
+end

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

@@ -0,0 +1,137 @@
+module TestBenchIsolated
+  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
+end

data/lib/test_bench_isolated/test_bench/run/output/summary/error.rb

@@ -0,0 +1,141 @@
+module TestBenchIsolated
+  module TestBench
+    class Run
+      module Output
+        class Summary
+          class Error
+            StateError = Class.new(RuntimeError)
+  
+            include TestBench::Output
+            include Events
+  
+            attr_accessor :current_file
+  
+            def failure_summary
+              @failure_summary ||= {}
+            end
+            attr_writer :failure_summary
+  
+            handle FileStarted do |file_started|
+              file = file_started.file
+  
+              start_file(file)
+            end
+  
+            handle Session::Events::Failed do
+              current_file.record_failure
+            end
+  
+            handle FileFinished do |file_finished|
+              file = file_finished.file
+              result = file_finished.result
+  
+              finish_file(file, result)
+            end
+  
+            handle FileCrashed do |file_crashed|
+              file = file_crashed.file
+  
+              error_message = file_crashed.error_message
+  
+              finish_file(file, error_message:)
+            end
+  
+            handle Finished do |finished|
+              if not failure_summary.empty?
+                print_summary
+              end
+            end
+  
+            def print_summary
+              writer.style(:bold, :underline, :red).puts("Failure Summary:")
+  
+              failure_summary.each_value do |file_record|
+                file, failures, error_message = file_record.to_a
+  
+                writer
+                  .style(:faint, :red)
+                  .print("-")
+                  .style(:reset_intensity, :bold)
+                  .print(" #{file}")
+                  .style(:reset_intensity)
+                  .print(":")
+  
+                if failures > 0
+                  writer.print(" %i failure%s" % [
+                    failures,
+                    failures == 1 ? '' : 's'
+                  ])
+  
+                  if not error_message.nil?
+                    writer.print(".")
+                  end
+                end
+  
+                if not error_message.nil?
+                  writer.puts(" File crashed, error:")
+  
+                  writer.style(:red).puts("  #{error_message}")
+                else
+                  writer.puts
+                end
+  
+                writer.puts
+              end
+            end
+  
+            def start_file(file)
+              if not current_file.nil?
+                raise StateError, "Already started file #{current_file.file.inspect} (File: #{file.inspect})"
+              end
+  
+              file = File.build(file)
+  
+              self.current_file = file
+            end
+  
+            def finish_file(file, result=nil, error_message: nil)
+              result ||= false
+  
+              if not current_file?(file)
+                raise StateError, "Cannot finish file #{file.inspect} (Current File: #{current_file&.file.inspect})"
+              end
+  
+              if not result
+                if not error_message.nil?
+                  current_file.error_message = error_message
+                end
+  
+                failure_summary[file] = current_file
+              end
+  
+              self.current_file = nil
+            end
+  
+            def current_file?(file=nil)
+              return false if current_file.nil?
+  
+              if not file.nil?
+                file == current_file.file
+              else
+                true
+              end
+            end
+  
+            File = Struct.new(:file, :failures, :error_message) do
+              def self.build(file)
+                failures = 0
+  
+                new(file, failures)
+              end
+  
+              def record_failure
+                self.failures += 1
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench_isolated/test_bench/run/output/summary.rb

@@ -0,0 +1,184 @@
+module TestBenchIsolated
+  module TestBench
+    class Run
+      module Output
+        class Summary
+          StateError = Class.new(RuntimeError)
+  
+          include TestBench::Output
+          include Session::Events
+          include Events
+  
+          def tests_finished
+            @tests_finished ||= 0
+          end
+          attr_writer :tests_finished
+  
+          def tests_passed
+            @tests_passed ||= 0
+          end
+          attr_writer :tests_passed
+  
+          def tests_failed
+            @tests_failed ||= 0
+          end
+          attr_writer :tests_failed
+  
+          def tests_skipped
+            @tests_skipped ||= 0
+          end
+          attr_writer :tests_skipped
+  
+          def contexts_skipped
+            @contexts_skipped ||= 0
+          end
+          attr_writer :contexts_skipped
+  
+          def files_finished
+            @files_finished ||= 0
+          end
+          attr_writer :files_finished
+  
+          def files_crashed
+            @files_crashed ||= 0
+          end
+          attr_writer :files_crashed
+  
+          attr_accessor :start_time
+          attr_accessor :finish_time
+          attr_accessor :elapsed_time
+  
+          handle TestFinished do |test_finished|
+            self.tests_finished += 1
+  
+            if test_finished.result
+              self.tests_passed += 1
+            else
+              self.tests_failed += 1
+            end
+          end
+  
+          handle TestSkipped do
+            self.tests_skipped += 1
+          end
+  
+          handle ContextSkipped do
+            self.contexts_skipped += 1
+          end
+  
+          handle FileFinished do
+            self.files_finished += 1
+          end
+  
+          handle FileCrashed do
+            self.files_crashed += 1
+          end
+  
+          handle Started do |started|
+            start_time = started.metadata.time
+  
+            self.start_time = start_time
+          end
+  
+          handle Finished do |finished|
+            finish_time = finished.metadata.time
+  
+            record_finish_time(finish_time)
+  
+            finish
+          end
+  
+          def record_finish_time(finish_time)
+            if start_time.nil?
+              raise StateError, "Start time isn't set"
+            end
+  
+            self.finish_time = finish_time
+  
+            elapsed_time = finish_time - start_time
+            self.elapsed_time = elapsed_time
+          end
+  
+          def finish
+            writer.print("Finished running %i file%s, " % [
+              files_finished,
+              files_finished == 1 ? '' : 's'
+            ])
+  
+            if files_crashed > 0
+              writer
+                .style(:bold, :red)
+                .puts("%i file%s crashed" % [
+                  files_crashed,
+                  files_crashed == 1 ? '' : 's'
+                ])
+            else
+              writer.puts("0 files crashed")
+            end
+  
+            writer.print("Ran %i test%s" % [
+              tests_finished,
+              tests_finished == 1 ? '' : 's'
+            ])
+  
+            if not elapsed_time.nil?
+              tests_per_second = tests_finished / elapsed_time
+              writer.print(" in %0.3fs (%i test%s/second)" % [
+                elapsed_time,
+                tests_per_second,
+                tests_finished == 1 ? '' : 's'
+              ])
+            end
+            writer.puts
+  
+            skip_count = tests_skipped + contexts_skipped
+  
+            if tests_passed > 0
+              if skip_count.zero? && tests_failed.zero?
+                writer.style(:bold)
+              end
+  
+              writer
+                .style(:green)
+                .print("#{tests_passed} passed")
+                .style(:reset_fg)
+  
+              if skip_count.zero? && tests_failed.zero?
+                writer.style(:reset_intensity)
+              end
+            else
+              writer
+                .style(:bold, :faint, :italic)
+                .print("0 passed")
+                .style(:reset_italic, :reset_intensity)
+            end
+            writer.print(", ")
+  
+            if skip_count.zero?
+              writer.print("0 skipped")
+            else
+              writer
+                .style(:bold, :yellow)
+                .print("%i%s skipped" % [
+                  skip_count,
+                  contexts_skipped > 0 ? '+' : ''
+                ])
+                .style(:reset_fg, :reset_intensity)
+            end
+            writer.print(", ")
+  
+            if tests_failed > 0
+              writer
+                .style(:bold, :red)
+                .puts("#{tests_failed} failed")
+            else
+              writer.puts("0 failed")
+            end
+  
+            writer.puts
+          end
+        end
+      end
+    end
+  end
+end