test_bench 1.0.0.0

data/lib/test_bench/output/levels/summary.rb

@@ -0,0 +1,21 @@
+module TestBench
+  module Output
+    module Levels
+      class Summary
+        include TestBench::Fixture::Output
+
+        include Output::Summary::Error
+        include Output::Summary::Run
+
+        def self.build(writer: nil, styling: nil, device: nil)
+          warn "Warning: #{self} is deprecated. It will remain in the TestBench v2 series, but will be removed from TestBench v3"
+
+          instance = new
+          Writer.configure(instance, writer: writer, styling: styling, device: device)
+          Timer.configure(instance)
+          instance
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/output/print_error.rb

@@ -0,0 +1,163 @@
+module TestBench
+  module Output
+    module PrintError
+      include Writer::Dependency
+
+      def omit_backtrace_pattern
+        @omit_backtrace_pattern ||= Defaults.omit_backtrace_pattern
+      end
+      attr_writer :omit_backtrace_pattern
+
+      def reverse_backtraces
+        instance_variable_defined?(:@reverse_backtraces) ?
+          @reverse_backtraces :
+          @reverse_backtraces = Defaults.reverse_backtraces
+      end
+      attr_writer :reverse_backtraces
+
+      def print_error(error)
+        PrintError.(error, writer: writer, omit_backtrace_pattern: omit_backtrace_pattern, reverse_backtraces: reverse_backtraces)
+      end
+
+      def self.call(error, writer: nil, omit_backtrace_pattern: nil, reverse_backtraces: nil)
+        writer ||= Writer.build
+        omit_backtrace_pattern ||= Defaults.omit_backtrace_pattern
+        reverse_backtraces = Defaults.reverse_backtraces if reverse_backtraces.nil?
+
+        writer.escape_code(:red)
+
+        if reverse_backtraces && error.backtrace.length > 1
+          writer
+            .indent
+            .escape_code(:bold)
+            .text("Traceback")
+            .escape_code(:reset_intensity)
+            .text(" (most recent call last):")
+            .newline
+        end
+
+        error(error, writer: writer, omit_backtrace_pattern: omit_backtrace_pattern, reverse_backtraces: reverse_backtraces)
+
+        writer
+          .escape_code(:reset_fg)
+          .sync
+      end
+
+      def self.error(error, writer: nil, omit_backtrace_pattern: nil, reverse_backtraces: nil)
+        reverse_backtraces = self.reverse_backtraces if reverse_backtraces.nil?
+
+        if reverse_backtraces
+          error_cause(error, writer: writer, omit_backtrace_pattern: omit_backtrace_pattern, reverse_backtraces: reverse_backtraces)
+          error_backtrace(error, writer: writer, omit_backtrace_pattern: omit_backtrace_pattern, reverse_backtraces: reverse_backtraces)
+          error_message(error, writer: writer)
+        else
+          error_message(error, writer: writer)
+          error_backtrace(error, writer: writer, omit_backtrace_pattern: omit_backtrace_pattern, reverse_backtraces: reverse_backtraces)
+          error_cause(error, writer: writer, omit_backtrace_pattern: omit_backtrace_pattern, reverse_backtraces: reverse_backtraces)
+        end
+      end
+
+      def self.error_cause(error, **args)
+        error(error.cause, **args) unless error.cause.nil?
+      end
+
+      def self.error_message(error, writer: nil)
+        caller_location = error.backtrace[0]
+
+        message = error.message
+
+        error_class = error.class.name
+
+        writer
+          .indent
+          .text("#{caller_location}: ")
+          .escape_code(:bold)
+          .text("#{message} (")
+          .escape_code(:underline)
+          .text(error_class)
+          .escape_code(:reset_underline)
+          .text(")")
+          .escape_code(:reset_intensity)
+          .newline
+      end
+
+      def self.error_backtrace(error, writer: nil, omit_backtrace_pattern: nil, reverse_backtraces: nil)
+        writer ||= self.writer
+        omit_backtrace_pattern ||= self.omit_backtrace_pattern
+        reverse_backtraces = self.reverse_backtraces if reverse_backtraces.nil?
+
+        omitting = false
+
+        backtrace = error.backtrace[1..-1]
+
+        unless reverse_backtraces
+          backtrace_iterator = backtrace.each.with_index
+        else
+          frame_count = backtrace.count
+
+          number_width = frame_count.to_s.each_char.count
+
+          backtrace_iterator = backtrace.reverse_each.map.with_index do |location, index|
+            ordinal = frame_count - index
+
+            ordinal = ordinal.to_s.rjust(number_width, ' ')
+
+            [location, ordinal]
+          end
+        end
+
+        backtrace_iterator.each do |location, ordinal|
+          omit = omit_backtrace_pattern.match?(location)
+
+          next if omit && omitting
+
+          writer
+            .text("\t")
+            .indent
+
+          if omit
+            omitting = true
+
+            if reverse_backtraces
+              ordinal.gsub!(/[[:digit:]]/, '?')
+
+              writer.text("#{ordinal}: ")
+            end
+
+            writer
+              .escape_code(:faint)
+              .escape_code(:italic)
+              .text('*omitted*')
+              .escape_code(:reset_italic)
+              .escape_code(:reset_intensity)
+
+          else
+            omitting = false
+
+            if reverse_backtraces
+              writer.text("#{ordinal}: ")
+            end
+
+            writer.text("from #{location}")
+          end
+
+          writer.newline
+        end
+      end
+
+      module Defaults
+        def self.omit_backtrace_pattern
+          pattern = ENV.fetch('TEST_BENCH_OMIT_BACKTRACE_PATTERN') do
+            'test_bench'
+          end
+
+          Regexp.new(pattern)
+        end
+
+        def self.reverse_backtraces
+          Environment::Boolean.fetch('TEST_BENCH_REVERSE_BACKTRACES', false)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module TestBench
+  module Output
+    module Summary
+      module Error
+        include Writer::Dependency
+
+        def self.included(cls)
+          cls.prepend(OutputMethods)
+        end
+
+        def error_summary_errors
+          @error_summary_errors ||= Hash.new do |hash, key|
+            hash[key] = []
+          end
+        end
+        attr_writer :error_summary_errors
+
+        attr_accessor :error_summary_current_file
+
+        def error_summary
+          return if error_summary_errors.empty?
+
+          writer
+            .escape_code(:bold)
+            .escape_code(:red)
+            .text('Error Summary:')
+            .escape_code(:reset_intensity)
+            .escape_code(:reset_fg)
+            .newline
+
+          error_summary_errors.each do |file, errors|
+            error_count = errors.count
+
+            writer
+              .text(error_count.to_s.rjust(4, ' '))
+              .text(": #{file}")
+              .newline
+
+            errors.each do |error|
+              writer
+                .text('      ')
+                .escape_code(:red)
+
+              PrintError.error_message(error, writer: writer)
+
+              writer.escape_code(:reset_fg)
+            end
+          end
+
+          writer.newline
+        end
+
+        module OutputMethods
+          def enter_file(file)
+            super
+
+            self.error_summary_current_file = file
+          end
+
+          def error(error)
+            super
+
+            current_file = error_summary_current_file
+
+            self.error_summary_errors[current_file] << error
+          end
+
+          def finish(_)
+            super
+
+            error_summary
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+module TestBench
+  module Output
+    module Summary
+      module Run
+        include Writer::Dependency
+        extend Print
+
+        def self.included(cls)
+          cls.prepend(OutputMethods)
+        end
+
+        def file_count
+          @file_count ||= 0
+        end
+        attr_writer :file_count
+
+        def test_count
+          @test_count ||= 0
+        end
+        attr_writer :test_count
+
+        def pass_count
+          @pass_count ||= 0
+        end
+        attr_writer :pass_count
+
+        def skip_count
+          @skip_count ||= 0
+        end
+        attr_writer :skip_count
+
+        def failure_count
+          @failure_count ||= 0
+        end
+        attr_writer :failure_count
+
+        def error_count
+          @error_count ||= 0
+        end
+        attr_writer :error_count
+
+        def elapsed_time
+          @elapsed_time ||= 0
+        end
+        attr_writer :elapsed_time
+
+        def timer
+          @timer ||= Timer::Substitute.build
+        end
+        attr_writer :timer
+
+        module OutputMethods
+          def enter_file(_)
+            super
+
+            timer.start
+          end
+
+          def exit_file(_, _)
+            super
+
+            elapsed_time = timer.stop
+
+            self.elapsed_time += elapsed_time
+
+            self.file_count += 1
+          end
+
+          def finish_test(_, result)
+            super
+
+            self.test_count += 1
+
+            if result
+              self.pass_count += 1
+            else
+              self.failure_count += 1
+            end
+          end
+
+          def skip_test(_)
+            super
+
+            self.skip_count += 1
+          end
+
+          def error(_)
+            super
+
+            self.error_count += 1
+          end
+
+          def finish(_)
+            super
+
+            Print.(file_count: file_count, test_count: test_count, pass_count: pass_count, skip_count: skip_count, failure_count: failure_count, error_count: error_count, elapsed_time: elapsed_time, writer: writer)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+module TestBench
+  module Output
+    module Summary
+      module Run
+        module Print
+          extend self
+
+          def call(file_count: nil, test_count: nil, pass_count: nil, skip_count: nil, failure_count: nil, error_count: nil, elapsed_time: nil, writer: nil)
+            file_count ||= 0
+            test_count ||= 0
+            pass_count ||= 0
+            skip_count ||= 0
+            failure_count ||= 0
+            error_count ||= 0
+            elapsed_time ||= 0
+            writer ||= Writer.build
+
+            failed = error_count > 0
+
+            if elapsed_time.nonzero?
+              tests_per_second = test_count / elapsed_time
+            end
+
+            if failed
+              writer.escape_code(:red)
+            end
+
+            writer
+              .text("Finished running #{numeric_label(file_count, 'file')}")
+              .newline
+              .text("Ran %s in %.3fs (%.1f tests/second)" % [
+                numeric_label(test_count, 'test'),
+                elapsed_time,
+                tests_per_second || 0])
+              .newline
+
+            if pass_count.nonzero? && !failed
+              writer
+                .escape_code(:green)
+                .text("#{pass_count} passed")
+                .escape_code(:reset_fg)
+            else
+              writer.text("#{pass_count} passed")
+            end
+
+            writer.text(", ")
+
+            if skip_count.nonzero? && !failed
+              writer
+                .escape_code(:yellow)
+                .text("#{skip_count} skipped")
+                .escape_code(:reset_fg)
+            else
+              writer.text("#{skip_count} skipped")
+            end
+
+            writer.text(", ")
+
+            if failure_count.nonzero?
+              writer
+                .escape_code(:bold)
+                .text("#{failure_count} failed")
+                .escape_code(:reset_intensity)
+            else
+              writer.text("0 failed")
+            end
+
+            writer.text(", ")
+
+            if failed
+              writer
+                .escape_code(:bold)
+                .text(numeric_label(error_count, 'total error'))
+                .escape_code(:reset_intensity)
+                .escape_code(:reset_fg)
+            else
+              writer.text("0 total errors")
+            end
+
+            2.times do
+              writer.newline
+            end
+          end
+
+          def numeric_label(number, label, plural_text=nil)
+            plural_text ||= 's'
+
+            if number == 1
+              "#{number} #{label}"
+            else
+              "#{number} #{label}#{plural_text}"
+            end
+          end
+        end
+      end
+    end
+  end
+end