test_bench 1.0.0.0

data/lib/test_bench/output.rb

@@ -0,0 +1,9 @@
+module TestBench
+  module Output
+    def self.build(**args)
+      Build.(**args)
+    end
+
+    Substitute = Fixture::Output::Substitute
+  end
+end

data/lib/test_bench/output/build.rb

@@ -0,0 +1,57 @@
+module TestBench
+  module Output
+    module Build
+      Error = Class.new(RuntimeError)
+
+      def self.call(level: nil, **args)
+        level ||= Defaults.level
+
+        level_setting = level
+
+        cls = level_class(level_setting)
+
+        cls.build(**args)
+      end
+
+      def self.level_class(level_setting)
+        assure_level(level_setting)
+
+        levels.fetch(level_setting)
+      end
+
+      def self.levels
+        {
+          :none => Levels::None,
+          :summary => Levels::Summary,
+          :failure => Levels::Failure,
+          :pass => Levels::Pass,
+          :debug => Levels::Debug
+        }
+      end
+
+      def self.level_settings
+        levels.keys
+      end
+
+      def self.assure_level(level_setting)
+        unless level_settings.include?(level_setting)
+          raise Error, "Unknown output level #{level_setting.inspect} (Valid levels: #{level_settings.map(&:inspect) * ', '})"
+        end
+      end
+
+      module Defaults
+        def self.level
+          verbose = Environment::Boolean.fetch('VERBOSE')
+
+          if verbose.nil?
+            level_text = ENV.fetch('TEST_BENCH_OUTPUT_LEVEL', 'pass')
+
+            level_text.to_sym
+          else
+            :debug
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,229 @@
+module TestBench
+  module Output
+    module Levels
+      class Debug
+        include TestBench::Fixture::Output
+
+        include Writer::Dependency
+
+        include PrintError
+
+        include Output::Summary::Error
+        include Output::Summary::Run
+
+        def previous_byte_offset
+          @previous_byte_offset ||= 0
+        end
+        attr_writer :previous_byte_offset
+
+        def self.build(omit_backtrace_pattern: nil, reverse_backtraces: nil, writer: nil, styling: nil, device: nil)
+          instance = new
+
+          instance.omit_backtrace_pattern = omit_backtrace_pattern unless omit_backtrace_pattern.nil?
+          instance.reverse_backtraces = reverse_backtraces unless reverse_backtraces.nil?
+
+          Writer.configure(instance, writer: writer, styling: styling, device: device)
+          Timer.configure(instance)
+
+          instance
+        end
+
+        def comment(text)
+          writer
+            .indent
+            .text(text)
+            .newline
+        end
+
+        def error(error)
+          print_error(error)
+        end
+
+        def finish_test(title, result)
+          writer.decrease_indentation
+
+          fg_color = result ? :green : :red
+
+          writer.indent
+
+          writer
+            .escape_code(fg_color)
+            .text("Finished test")
+
+          unless title.nil?
+            writer
+              .text(' ')
+              .escape_code(:bold)
+              .text(title.inspect)
+              .escape_code(:reset_intensity)
+          end
+
+          writer
+            .text(" (Result: #{result ? 'pass' : 'failure'})")
+            .escape_code(:reset_fg)
+            .newline
+        end
+
+        def skip_test(title)
+          writer.indent
+
+          writer
+            .escape_code(:yellow)
+            .text("Skipped test")
+
+          unless title.nil?
+            writer
+              .text(' ')
+              .escape_code(:bold)
+              .text(title.inspect)
+              .escape_code(:reset_intensity)
+          end
+
+          writer
+            .escape_code(:reset_fg)
+            .newline
+        end
+
+        def start_test(title)
+          if title.nil?
+            text = "Starting test"
+          else
+            text = "Starting test #{title.inspect}"
+          end
+
+          writer
+            .indent
+            .escape_code(:cyan)
+            .text(text)
+            .escape_code(:reset_fg)
+            .newline
+
+          writer.increase_indentation
+        end
+
+        def enter_context(title)
+          return if title.nil?
+
+          writer
+            .indent
+            .escape_code(:green)
+            .text(title)
+            .escape_code(:reset_fg)
+            .newline
+
+          writer.increase_indentation
+        end
+
+        def exit_context(title, result)
+          return if title.nil?
+
+          writer.decrease_indentation
+
+          fg_color = result ? :green : :red
+
+          text = "Finished context #{title.inspect} (Result: #{result ? 'pass' : 'failure'})"
+
+          writer
+            .indent
+            .escape_code(:faint)
+            .escape_code(:italic)
+            .escape_code(fg_color)
+            .text(text)
+            .escape_code(:reset_fg)
+            .escape_code(:reset_italic)
+            .escape_code(:reset_intensity)
+            .newline
+
+          writer.newline if writer.indentation_depth.zero?
+        end
+
+        def skip_context(title)
+          return if title.nil?
+
+          writer
+            .indent
+            .escape_code(:yellow)
+            .text(title)
+            .escape_code(:reset_fg)
+            .newline
+
+          writer.newline if writer.indentation_depth.zero?
+        end
+
+        def start_fixture(fixture)
+          fixture_class = fixture.class.inspect
+
+          writer
+            .indent
+            .escape_code(:blue)
+            .text("Starting fixture (Fixture: #{fixture_class})")
+            .escape_code(:reset_fg)
+            .newline
+
+          writer.increase_indentation
+        end
+
+        def finish_fixture(fixture, result)
+          fixture_class = fixture.class.inspect
+
+          writer.decrease_indentation
+
+          writer
+            .indent
+            .escape_code(:magenta)
+            .text("Finished fixture (Fixture: #{fixture_class}, Result: #{result ? 'pass' : 'failure'})")
+            .escape_code(:reset_fg)
+            .newline
+
+          writer.newline if writer.indentation_depth.zero?
+        end
+
+        def enter_file(file)
+          text = "Running #{file}"
+
+          writer.text(text).newline
+
+          self.previous_byte_offset = writer.byte_offset
+        end
+
+        def exit_file(file, _)
+          unless writer.byte_offset > previous_byte_offset
+            writer
+              .escape_code(:faint)
+              .text("(Nothing written)")
+              .escape_code(:reset_intensity)
+              .newline
+
+            writer.newline
+          end
+        end
+
+        def enter_assert_block(caller_location)
+          text = "Entered assert block (Caller Location: #{caller_location})"
+
+          writer
+            .indent
+            .escape_code(:blue)
+            .text(text)
+            .escape_code(:reset_fg)
+            .newline
+
+          writer.increase_indentation
+        end
+
+        def exit_assert_block(caller_location, result)
+          writer.decrease_indentation
+
+          text = "Exited assert block (Caller Location: #{caller_location}, Result: #{result ? 'pass' : 'failure'})"
+
+          writer
+            .indent
+            .escape_code(:cyan)
+            .text(text)
+            .escape_code(:reset_fg)
+            .newline
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module TestBench
+  module Output
+    module Levels
+      class Failure
+        include TestBench::Fixture::Output
+
+        include Output::PrintError
+        include Output::Summary::Error
+
+        def self.build(omit_backtrace_pattern: nil, reverse_backtraces: nil, 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
+
+          instance.omit_backtrace_pattern = omit_backtrace_pattern unless omit_backtrace_pattern.nil?
+          instance.reverse_backtraces = reverse_backtraces unless reverse_backtraces.nil?
+
+          Writer.configure(instance, writer: writer, styling: styling, device: device)
+
+          instance
+        end
+
+        def error(error)
+          print_error(error)
+
+          writer.newline
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module TestBench
+  module Output
+    module Levels
+      class None < Fixture::Output::Null
+        def self.build
+          warn "Warning: #{self} is deprecated. It will remain in the TestBench v2 series, but will be removed from TestBench v3"
+
+          new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,274 @@
+module TestBench
+  module Output
+    module Levels
+      class Pass
+        include TestBench::Fixture::Output
+
+        include Writer::Dependency
+
+        include PrintError
+
+        include Output::Summary::Error
+        include Output::Summary::Run
+
+        attr_accessor :previous_error
+
+        def previous_byte_offset
+          @previous_byte_offset ||= 0
+        end
+        attr_writer :previous_byte_offset
+
+        def assert_block_stack
+          @assert_block_stack ||= AssertBlockStack.new(writer)
+        end
+        attr_writer :assert_block_stack
+
+        def test_stack
+          @test_stack ||= []
+        end
+        attr_writer :test_stack
+
+        def self.build(omit_backtrace_pattern: nil, reverse_backtraces: nil, writer: nil, styling: nil, device: nil)
+          instance = new
+
+          instance.omit_backtrace_pattern = omit_backtrace_pattern unless omit_backtrace_pattern.nil?
+          instance.reverse_backtraces = reverse_backtraces unless reverse_backtraces.nil?
+
+          Writer.configure(instance, writer: writer, styling: styling, device: device)
+          Timer.configure(instance)
+
+          instance
+        end
+
+        def comment(text)
+          writer
+            .indent
+            .text(text)
+            .newline
+        end
+
+        def error(error)
+          self.previous_error = error
+        end
+
+        def print_previous_error
+          print_error(previous_error)
+
+          self.previous_error = nil
+        end
+
+        def start_test(_)
+          test_stack.push(true)
+        end
+
+        def finish_test(title, result)
+          test_stack.pop
+
+          unless result && title.nil?
+            writer.indent
+
+            writer.escape_code(:bold) unless result
+
+            fg_color = result ? :green : :red
+
+            writer
+              .escape_code(fg_color)
+              .text(title || 'Test')
+              .escape_code(:reset_fg)
+
+            writer.escape_code(:reset_intensity) unless result
+
+            writer.newline
+          end
+
+          unless previous_error.nil?
+            writer.increase_indentation
+
+            print_previous_error
+
+            writer.decrease_indentation
+          end
+
+          unless result
+            assert_block_stack.print_captured_text
+          end
+        end
+
+        def skip_test(title)
+          writer.indent
+
+          writer
+            .escape_code(:yellow)
+            .text(title || 'Test')
+            .escape_code(:reset_fg)
+
+          writer.newline
+        end
+
+        def enter_context(title)
+          test_stack.push(false)
+
+          return if title.nil?
+
+          writer
+            .indent
+            .escape_code(:green)
+            .text(title)
+            .escape_code(:reset_fg)
+            .newline
+
+          writer.increase_indentation
+        end
+
+        def exit_context(title, result)
+          test_stack.pop
+
+          print_previous_error unless previous_error.nil?
+
+          unless result
+            assert_block_stack.print_captured_text
+          end
+
+          return if title.nil?
+
+          writer.decrease_indentation
+
+          writer.newline if writer.indentation_depth.zero?
+        end
+
+        def skip_context(title)
+          return if title.nil?
+
+          writer
+            .indent
+            .escape_code(:yellow)
+            .text(title)
+            .escape_code(:reset_fg)
+            .newline
+
+          writer.newline if writer.indentation_depth.zero?
+        end
+
+        def enter_file(file)
+          text = "Running #{file}"
+
+          writer.text(text).newline
+
+          self.previous_byte_offset = writer.byte_offset
+        end
+
+        def exit_file(file, result)
+          print_previous_error unless previous_error.nil?
+
+          unless result
+            assert_block_stack.print_captured_text
+          end
+
+          unless writer.byte_offset > previous_byte_offset
+            writer
+              .escape_code(:faint)
+              .text("(Nothing written)")
+              .escape_code(:reset_intensity)
+              .newline
+
+            writer.newline
+          end
+        end
+
+        def finish_fixture(_, result)
+          print_previous_error unless previous_error.nil?
+
+          unless result
+            assert_block_stack.print_captured_text
+          end
+        end
+
+        def enter_assert_block(_)
+          inside_test = inside_test?
+
+          test_stack.push(false)
+
+          assert_block_stack.push
+
+          writer.increase_indentation
+          writer.increase_indentation if inside_test
+        end
+
+        def exit_assert_block(_, result)
+          test_stack.pop
+
+          print_previous_error unless previous_error.nil?
+
+          unless result
+            assert_block_stack.print_captured_text
+          end
+
+          discard_captured_text = result
+
+          assert_block_stack.pop(discard_captured_text)
+
+          writer.decrease_indentation if inside_test?
+          writer.decrease_indentation
+        end
+
+        def inside_test?
+          test_stack[-1]
+        end
+
+        class AssertBlockStack
+          def stack
+            @stack ||= []
+          end
+
+          attr_accessor :captured_text
+
+          attr_reader :writer
+
+          def initialize(writer)
+            @writer = writer
+          end
+
+          def push
+            capture_text = String.new
+
+            previous_device = writer.device
+
+            writer.device = StringIO.new(capture_text)
+
+            entry = Entry.new(capture_text, previous_device)
+
+            stack.push(entry)
+
+            entry
+          end
+
+          def pop(discard)
+            entry = stack.pop
+
+            writer.device = entry.previous_device
+
+            unless discard
+              self.captured_text = entry.capture_text
+            end
+
+            entry
+          end
+
+          def print_captured_text
+            return if captured_text.nil?
+
+            writer.text(captured_text)
+
+            self.captured_text = nil
+          end
+
+          def inside_test?
+            test_stack[-1]
+          end
+
+          Entry = Struct.new(:capture_text, :previous_device)
+        end
+      end
+    end
+  end
+end