test_bench 1.2.0.10 → 2.0.0.0.pre1

data/lib/test_bench/output/raw.rb

@@ -1,363 +0,0 @@
-module TestBench
-  module Output
-    class Raw
-      Error = Class.new(RuntimeError)
-
-      include Fixture::Output
-      include Writer::Dependency
-
-      include PrintError
-
-      def verbose
-        instance_variable_defined?(:@verbose) ?
-          @verbose :
-          @verbose = Defaults.verbose
-      end
-      attr_writer :verbose
-      alias_method :verbose?, :verbose
-
-      def detail_setting
-        @detail_setting ||= Defaults.detail
-      end
-      attr_writer :detail_setting
-
-      attr_accessor :current_batch
-
-      def batch_starting(batch_data)
-        if batch_data.depth.zero?
-          self.current_batch = batch_data
-        end
-      end
-
-      def batch_finished(batch_data)
-        if batch_data.depth.zero?
-          self.current_batch = nil
-        end
-      end
-
-      def previous_byte_offset
-        @previous_byte_offset ||= 0
-      end
-      attr_writer :previous_byte_offset
-
-      def configure(verbose: nil, detail: nil, omit_backtrace_pattern: nil, reverse_backtraces: nil, writer: nil, device: nil, styling: nil)
-        unless detail.nil?
-          self.class.assure_detail_setting(detail)
-        end
-
-        self.detail_setting = detail unless detail.nil?
-        self.verbose = verbose unless verbose.nil?
-
-        self.omit_backtrace_pattern = omit_backtrace_pattern unless omit_backtrace_pattern.nil?
-        self.reverse_backtraces = reverse_backtraces unless reverse_backtraces.nil?
-
-        Writer.configure(self, writer: writer, styling: styling, device: device)
-      end
-
-      def self.build(verbose: nil, detail: nil, omit_backtrace_pattern: nil, reverse_backtraces: nil, writer: nil, device: nil, styling: nil)
-        instance = new
-        instance.configure(verbose: verbose, detail: detail, omit_backtrace_pattern: omit_backtrace_pattern, reverse_backtraces: reverse_backtraces, writer: writer, device: device, styling: styling)
-        instance
-      end
-
-      def self.configure(receiver, attr_name: nil, **args)
-        attr_name ||= :raw_output
-
-        instance = build(**args)
-        receiver.public_send(:"#{attr_name}=", instance)
-        instance
-      end
-
-      def detail?(result=nil)
-        result ||= current_batch&.result
-
-        case detail_setting
-        when :failure
-          result != true
-        when :on
-          true
-        when :off
-          false
-        end
-      end
-
-      def enter_context(title, batch_data: nil)
-        batch_starting(batch_data) unless batch_data.nil?
-
-        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, batch_data: nil)
-        return if title.nil?
-
-        writer.decrease_indentation
-
-        if verbose?
-          text = "Finished context #{title.inspect} (Result: #{result_text(result)})"
-
-          color = result ? :green : :red
-
-          writer
-            .indent
-            .escape_code(:faint).escape_code(:italic).escape_code(color)
-            .text(text)
-            .escape_code(:reset_fg).escape_code(:reset_italic).escape_code(:reset_intensity)
-            .newline
-        end
-
-        if writer.indentation_depth.zero?
-          writer.newline
-        end
-
-      ensure
-        batch_finished(batch_data) unless batch_data.nil?
-      end
-
-      def skip_context(title)
-        return if title.nil?
-
-        writer
-          .indent
-          .escape_code(:yellow)
-          .text(title)
-          .escape_code(:reset_fg)
-          .newline
-      end
-
-      def start_test(title, batch_data: nil)
-        batch_starting(batch_data) unless batch_data.nil?
-
-        batch_data = nil if verbose
-
-        if batch_data&.passed? && title.nil?
-          return
-        end
-
-        if batch_data.nil?
-          if title.nil?
-            text = "Starting test"
-          else
-            text = "Starting test #{title.inspect}"
-          end
-
-          writer
-            .indent
-            .escape_code(:faint)
-            .escape_code(:italic)
-            .escape_code(:blue)
-            .text(text)
-            .escape_code(:reset_fg)
-            .escape_code(:reset_italic)
-            .escape_code(:reset_intensity)
-            .newline
-
-        else
-          result = batch_data.result
-
-          print_test_result(title, result)
-        end
-
-        writer.increase_indentation
-      end
-
-      def finish_test(title, result, batch_data: nil)
-        batch_data = nil if verbose?
-
-        if batch_data&.passed? && title.nil?
-          return
-        end
-
-        writer.decrease_indentation
-
-        if batch_data.nil?
-          print_test_result(title, result)
-        end
-
-      ensure
-        batch_finished(batch_data) unless batch_data.nil?
-      end
-
-      def print_test_result(title, result)
-        title ||= default_test_title
-
-        if writer.styling?
-          text = title
-        elsif result
-          text = title
-        else
-          text = "#{title} (failed)"
-        end
-
-        color = result ? :green : :red
-
-        writer.indent
-
-        if result
-          writer.escape_code(:green)
-        else
-          writer.escape_code(:bold).escape_code(:red)
-        end
-
-        writer.text(text)
-
-        writer.escape_code(:reset_fg)
-        unless result
-          writer.escape_code(:reset_intensity)
-        end
-
-        writer.newline
-      end
-
-      def skip_test(title)
-        title ||= default_test_title
-
-        if writer.styling?
-          text = title
-        else
-          text = "#{title} (skipped)"
-        end
-
-        writer
-          .indent
-          .escape_code(:yellow)
-          .text(text)
-          .escape_code(:reset_fg)
-          .newline
-      end
-
-      def start_fixture(fixture, batch_data: nil)
-        batch_starting(batch_data) unless batch_data.nil?
-
-        return unless verbose?
-
-        fixture_class = fixture.class.inspect
-
-        text = "Starting fixture (Fixture: #{fixture_class})"
-
-        writer
-          .indent
-          .escape_code(:blue)
-          .text(text)
-          .escape_code(:reset_fg)
-          .newline
-
-        writer.increase_indentation
-      end
-
-      def finish_fixture(fixture, result, batch_data: nil)
-        return unless verbose?
-
-        fixture_class = fixture.class.inspect
-
-        text = "Finished fixture (Fixture: #{fixture_class}, Result: #{result_text(result)})"
-
-        writer.decrease_indentation
-
-        writer
-          .indent
-          .escape_code(:magenta)
-          .text(text)
-          .escape_code(:reset_fg)
-          .newline
-
-      ensure
-        batch_finished(batch_data) unless batch_data.nil?
-      end
-
-      def error(error)
-        print_error(error)
-      end
-
-      def comment(text)
-        writer
-          .indent
-          .text(text)
-          .newline
-      end
-
-      def detail(text)
-        return unless verbose? || detail?
-
-        if verbose? && !detail?
-          text = "(detail omitted: #{text})"
-        end
-
-        writer
-          .indent
-          .text(text)
-          .newline
-      end
-
-      def enter_file(path)
-        text = "Running #{path}"
-
-        writer.text(text).newline
-
-        self.previous_byte_offset = writer.byte_offset
-      end
-
-      def exit_file(path, result)
-        unless writer.byte_offset > previous_byte_offset
-          writer
-            .escape_code(:faint)
-            .text("(Nothing written)")
-            .escape_code(:reset_intensity)
-            .newline
-
-          writer.newline
-        end
-      end
-
-      def result_text(result)
-        result ? 'pass' : 'failure'
-      end
-
-      def default_test_title
-        'Test'
-      end
-
-      def self.assure_detail_setting(detail_setting)
-        unless detail_settings.include?(detail_setting)
-          raise Error, "Invalid detail setting #{detail_setting.inspect} (Valid values: #{detail_settings.map(&:inspect).join(', ')})"
-        end
-      end
-
-      def self.detail_settings
-        [
-          :failure,
-          :on,
-          :off
-        ]
-      end
-
-      def self.default_detail_setting
-        detail_settings.fetch(0)
-      end
-
-      module Defaults
-        def self.verbose
-          Environment::Boolean.fetch('TEST_BENCH_VERBOSE', false)
-        end
-
-        def self.detail
-          detail = ::ENV['TEST_BENCH_DETAIL']
-
-          if detail.nil?
-            Raw.default_detail_setting
-          else
-            detail.to_sym
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,94 +0,0 @@
-module TestBench
-  module Output
-    class Summary
-      module Session
-        def self.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 self.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

data/lib/test_bench/output/summary.rb

@@ -1,146 +0,0 @@
-module TestBench
-  module Output
-    class Summary
-      include Fixture::Output
-
-      include Writer::Dependency
-
-      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
-
-      def errors_by_file
-        @errors_by_file ||= Hash.new do |hash, key|
-          hash[key] = []
-        end
-      end
-      attr_writer :errors_by_file
-
-      attr_accessor :current_file
-
-      def configure(writer: nil, device: nil, styling: nil)
-        Writer.configure(self, writer: writer, device: device, styling: styling)
-        Timer.configure(self)
-      end
-
-      def self.build(writer: nil, device: nil, styling: nil)
-        instance = new
-        instance.configure(writer: writer, device: device, styling: styling)
-        instance
-      end
-
-      def enter_file(file)
-        timer.start
-
-        self.current_file = file
-      end
-
-      def exit_file(_, _)
-        elapsed_time = timer.stop
-
-        self.elapsed_time += elapsed_time
-
-        self.file_count += 1
-      end
-
-      def finish_test(_, result)
-        self.test_count += 1
-
-        if result
-          self.pass_count += 1
-        else
-          self.failure_count += 1
-        end
-      end
-
-      def skip_test(_)
-        self.skip_count += 1
-      end
-
-      def error(error)
-        errors_by_file[current_file] << error
-
-        self.error_count += 1
-      end
-
-      def finish(_)
-        error_summary
-
-        session_summary
-      end
-
-      def session_summary
-        Session.(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
-
-      def error_summary
-        return if errors_by_file.empty?
-
-        writer
-          .escape_code(:bold)
-          .escape_code(:red)
-          .text('Error Summary:')
-          .escape_code(:reset_intensity)
-          .escape_code(:reset_fg)
-          .newline
-
-        errors_by_file.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
-    end
-  end
-end

data/lib/test_bench/output/timer/substitute.rb

@@ -1,45 +0,0 @@
-module TestBench
-  module Output
-    class Timer
-      module Substitute
-        def self.build
-          Timer.new
-        end
-
-        class Timer < Timer
-          def elapsed_time
-            @elapsed_time ||= 0.0
-          end
-          attr_writer :elapsed_time
-
-          def mode
-            @mode ||= Mode.stopped
-          end
-          attr_writer :mode
-
-          def start(_=nil)
-            if mode == Mode.running
-              raise Error, "Timer has already started"
-            end
-
-            self.mode = Mode.running
-          end
-
-          def stop(_=nil)
-            if mode == Mode.stopped
-              raise Error, "Timer has not started"
-            end
-
-            self.mode = Mode.stopped
-
-            elapsed_time.round(3)
-          end
-
-          def set(elapsed_time)
-            self.elapsed_time = elapsed_time
-          end
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/output/timer.rb

@@ -1,75 +0,0 @@
-module TestBench
-  module Output
-    class Timer
-      Error = Class.new(RuntimeError)
-
-      attr_accessor :start_time
-
-      def self.configure(receiver, attr_name: nil)
-        attr_name ||= :timer
-
-        instance = new
-        receiver.public_send(:"#{attr_name}=", instance)
-        instance
-      end
-
-      def start(now=nil)
-        now ||= ::Time.now.utc
-
-        if mode == Mode.running
-          raise Error, "Timer has already started (Start Time: #{start_time})"
-        end
-
-        self.start_time = now
-      end
-
-      def stop(now=nil)
-        now ||= ::Time.now.utc
-
-        if mode == Mode.stopped
-          raise Error, "Timer has not started"
-        end
-
-        start_time = reset
-
-        elapsed = now - start_time
-
-        elapsed.round(3)
-      end
-
-      def running?
-        mode == Mode.running
-      end
-
-      def stopped?
-        mode == Mode.stopped
-      end
-
-      def mode
-        if start_time.nil?
-          Mode.stopped
-        else
-          Mode.running
-        end
-      end
-
-      def reset
-        previous_start_time = self.start_time
-
-        self.start_time = nil
-
-        previous_start_time
-      end
-
-      module Mode
-        def self.running
-          :running
-        end
-
-        def self.stopped
-          :stopped
-        end
-      end
-    end
-  end
-end