test_bench 1.2.0.9 → 2.0.0.0.pre1

data/lib/test_bench/controls/pattern.rb

@@ -1,33 +0,0 @@
-module TestBench
-  module Controls
-    module Pattern
-      def self.example(text=nil)
-        text ||= self.text
-
-        escaped_text = Regexp.escape(text)
-
-        Regexp.new(escaped_text)
-      end
-
-      def self.text
-        'some-pattern'
-      end
-
-      module None
-        def self.example
-          /#{text}/
-        end
-
-        def self.text
-          '\z.'
-        end
-      end
-
-      module Invalid
-        def self.text
-          '('
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/controls/test_file.rb

@@ -1,5 +0,0 @@
-module TestBench
-  module Controls
-    TestFile = TestBench::Fixture::Controls::TestFile
-  end
-end

data/lib/test_bench/controls/time.rb

@@ -1,89 +0,0 @@
-module TestBench
-  module Controls
-    module Time
-      def self.example(seconds_offset: nil)
-        seconds_offset ||= 0
-
-        year = self.year
-        month = self.month
-        day = self.day
-
-        hours = self.hours
-        minutes = self.minutes
-        seconds = self.seconds + seconds_offset
-
-        if not RUBY_ENGINE == 'mruby'
-          tz_offset = self.tz_offset
-
-          final_argument = tz_offset
-        else
-          seconds, subseconds = seconds.divmod(1)
-
-          microseconds = subseconds * 1_000_000
-
-          final_argument = microseconds
-        end
-
-        ::Time.new(year, month, day, hours, minutes, seconds, final_argument)
-      end
-
-      def self.year
-        2000
-      end
-
-      def self.month
-        1
-      end
-
-      def self.day
-        1
-      end
-
-      def self.hours
-        11
-      end
-
-      def self.minutes
-        11
-      end
-
-      def self.seconds
-        11.0
-      end
-
-      def self.tz_offset
-        0
-      end
-
-      module Elapsed
-        def self.example
-          1.111
-        end
-
-        module Text
-          def self.example
-            "1.111s"
-          end
-        end
-
-        module PerSecond
-          def self.example
-            elapsed_time = Elapsed.example
-
-            Rational(ocurrences, elapsed_time)
-          end
-
-          def self.ocurrences
-            1
-          end
-
-          module Text
-            def self.example
-              "0.9"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/deactivation_variants.rb

@@ -1,11 +0,0 @@
-module TestBench
-  module DeactivationVariants
-    def _context(title=nil, &block)
-      context(title)
-    end
-
-    def _test(title=nil, &block)
-      test(title)
-    end
-  end
-end

data/lib/test_bench/environment/boolean.rb

@@ -1,40 +0,0 @@
-module TestBench
-  module Environment
-    module Boolean
-      Error = Class.new(RuntimeError)
-
-      def self.fetch(env_var, default_value=nil, env: nil)
-        value = get(env_var, env: env)
-
-        return default_value if value.nil?
-
-        value
-      end
-
-      def self.get(env_var, env: nil)
-        env ||= ::ENV
-
-        return nil unless env.key?(env_var)
-
-        text_value = env.fetch(env_var)
-
-        case text_value
-        when true_pattern
-          true
-        when false_pattern
-          false
-        else
-          raise Error, "Invalid boolean value for ENV variable #{env_var.inspect} (Value: #{text_value.inspect})"
-        end
-      end
-
-      def self.true_pattern
-        @true_pattern ||= %r{\A(?:on|yes|y|true|t|1)\z}ni
-      end
-
-      def self.false_pattern
-        @false_pattern ||= %r{\A(?:off|no|n|false|f|0)\z}ni
-      end
-    end
-  end
-end

data/lib/test_bench/fixtures/configure_receiver.rb

@@ -1,80 +0,0 @@
-module TestBench
-  module Fixtures
-    class ConfigureReceiver
-      include TestBench::Fixture
-
-      attr_reader :cls
-      attr_reader :default_attr_name
-
-      def args
-        @args ||= []
-      end
-
-      def kwargs
-        @kwargs ||= {}
-      end
-
-      def initialize(cls, default_attr_name, args=nil, kwargs=nil)
-        @cls = cls
-        @default_attr_name = default_attr_name
-        @args = args
-        @kwargs = kwargs
-      end
-
-      def self.build(cls, *args, attr_name:, **kwargs)
-        new(cls, attr_name, args, kwargs)
-      end
-
-      def call
-        test "Responds to configure" do
-          assert(cls.respond_to?(:configure))
-        end or return
-
-        context do
-          receiver = OpenStruct.new
-
-          instance = configure(receiver)
-
-          test "Attribute is set on receiver" do
-            refute(receiver.public_send(default_attr_name).nil?)
-          end
-
-          test "Returns the instance that was assigned" do
-            assert(receiver.public_send(default_attr_name).equal?(instance))
-          end
-        end
-
-        context "Optional Attribute Name" do
-          context "Given" do
-            receiver = OpenStruct.new
-            attr_name = :given_attr_name
-
-            configure(receiver, attr_name: attr_name)
-
-            test "Given attribute is set on receiver (Attribute: #{attr_name})" do
-              refute(receiver.public_send(attr_name).nil?)
-            end
-
-            test "Default attribute is not set on receiver" do
-              assert(receiver.public_send(default_attr_name).nil?)
-            end
-          end
-
-          context "Omitted" do
-            receiver = OpenStruct.new
-
-            configure(receiver)
-
-            test "Default attribute is set on receiver (Attribute: #{default_attr_name})" do
-              refute(receiver.public_send(default_attr_name).nil?)
-            end
-          end
-        end
-      end
-
-      def configure(receiver, attr_name: nil)
-        cls.configure(receiver, *args, attr_name: attr_name, **kwargs)
-      end
-    end
-  end
-end

data/lib/test_bench/fixtures.rb

@@ -1,5 +0,0 @@
-unless RUBY_ENGINE == 'mruby'
-  require 'ostruct'
-end
-
-require 'test_bench/fixtures/configure_receiver'

data/lib/test_bench/output/batch_data.rb

@@ -1,17 +0,0 @@
-module TestBench
-  module Output
-    BatchData = Struct.new(:result, :depth) do
-      def passed?
-        result
-      end
-
-      def failed?
-        !result
-      end
-
-      def toplevel?
-        depth.zero?
-      end
-    end
-  end
-end

data/lib/test_bench/output/buffer.rb

@@ -1,114 +0,0 @@
-module TestBench
-  module Output
-    class Buffer < Fixture::Output::Capture
-      attr_accessor :writer
-
-      def raw_output
-        @raw_output ||= Raw.new
-      end
-      attr_writer :raw_output
-
-      def stack
-        @stack ||= []
-      end
-
-      def self.build(verbose: nil, detail: nil, omit_backtrace_pattern: nil, reverse_backtraces: nil, writer: nil, device: nil, styling: nil)
-        instance = new
-
-        raw_output = Raw.configure(instance, verbose: verbose, detail: detail, omit_backtrace_pattern: omit_backtrace_pattern, reverse_backtraces: reverse_backtraces, writer: writer, device: device, styling: styling)
-
-        instance.writer = raw_output.writer
-
-        instance
-      end
-
-      def exit_context(*)
-        super
-
-        flush unless buffering?
-      end
-
-      def finish_test(*)
-        super
-
-        flush unless buffering?
-      end
-
-      def finish_fixture(*)
-        super
-
-        flush unless buffering?
-      end
-
-      def new_record(signal, data)
-        record = super
-
-        record.extend(Record)
-
-        case signal
-        when :enter_context, :start_test, :start_fixture
-          start_batch(record)
-
-        when :exit_context, :finish_test, :finish_fixture
-          result = record.data.last
-
-          finish_batch(record, result)
-        end
-
-        record
-      end
-
-      def start_batch(record)
-        record.start_batch(stack_depth)
-
-        stack.push(record)
-      end
-
-      def finish_batch(final_record, result)
-        first_record = stack.pop
-
-        batch_data = first_record.batch_data
-        batch_data.result = result
-
-        final_record.batch_data = first_record.batch_data
-      end
-
-      def flush
-        records.each do |record|
-          record.forward(raw_output)
-        end
-
-        records.clear
-      end
-
-      def buffering?
-        stack_depth.nonzero?
-      end
-
-      def stack_depth
-        stack.length
-      end
-
-      module Record
-        attr_accessor :batch_data
-
-        def forward(raw_output)
-          return super if batch_data.nil?
-
-          raw_output.public_send(signal, *data, batch_data: batch_data)
-        end
-
-        def start_batch(depth)
-          batch_data = Output::BatchData.new
-          batch_data.depth = depth
-
-          self.batch_data = batch_data
-        end
-
-        def finish_batch(result)
-          batch_data.result = result
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/output/log.rb

@@ -1,27 +0,0 @@
-module TestBench
-  module Output
-    module Log
-      def self.build(device=nil, level: nil)
-        level ||= Defaults.level
-
-        Fixture::Output::Log.build(device, level: level)
-      end
-
-      def self.default_level
-        :fatal
-      end
-
-      module Defaults
-        def self.level
-          level_text = ::ENV['TEST_BENCH_LOG_LEVEL']
-
-          if level_text.nil?
-            Log.default_level
-          else
-            level_text.to_sym
-          end
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/output/print_error.rb

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