test_bench 1.2.0.9 → 2.0.0.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05441cb83eef17edb08808484675951fdaeedcf33d3b60e77fe7a42d9810d995
-  data.tar.gz: c64e1a00db231505654bf87a9f12329b55de83a72983b581cc2f0a6003f02fd0
+  metadata.gz: ddd35ed7f146f0213d2d695324b613e2d3441fa9ca7d4ba4b7bcbd6846f9777a
+  data.tar.gz: b50a428e75cba2c1d14056a7dd5d592c0f7da48b34714bc297d86c4c39f85255
 SHA512:
-  metadata.gz: a00af27a3e6821af9b8fe4116b1be23dba6b8253266d8e17d23c176a4ef936cc64e31ba0b5c58c8cab0021044e0b9a8f9405c0fde30770e27390005179a5ce40
-  data.tar.gz: 114f737345753f230865a4957757409308f3d3d780844a4b1edc9c4d9b8f57f0ec7fcf25315dac8e4011774d8e687edea8741c5272a68427e2d5c724c3fd70f6
+  metadata.gz: 5bf68a6e4005ac94c5f19257f7013796df2ae5ba5a5c48065d48cea9efd01076bf288d2f288d6c93137f0ad633640801d1a6366082ed41d67354da4ddf5507f2
+  data.tar.gz: b37710cd1cc8b6a852d0b7a3c1879b8270aadba059611c328fd28627d79f65344e1dfe08a4a4d8b2c47215623de8f81ae9d4e4f019e1e1b9e8bfa7bb37e46423

data/lib/test_bench/cli.rb

@@ -1,43 +1,293 @@
 module TestBench
-  module CLI
-    def self.call(tests_directory=nil, exclude_file_pattern: nil)
-      tests_directory ||= Defaults.tests_directory
+  class CLI
+    ArgumentError = Class.new(RuntimeError)
 
-      path_arguments = ParseArguments.()
+    attr_reader :arguments
 
-      read_stdin = $stdin.stat.pipe?
+    attr_accessor :exit_code
 
-      if read_stdin && $stdin.eof?
-        STDERR.puts "$stdin is a pipe, but no data was written to it; no test files will be run"
+    def env
+      @env ||= {}
+    end
+    attr_writer :env
+
+    def program_name
+      @program_name ||= Defaults.program_name
+    end
+    attr_writer :program_name
+
+    def version
+      @version ||= Defaults.version
+    end
+    attr_writer :version
+
+    def stdin
+      @stdin ||= STDIN
+    end
+    attr_writer :stdin
+
+    def writer
+      @writer ||= Output::Writer::Substitute.build
+    end
+    attr_writer :writer
+
+    def run
+      @run ||= Run::Substitute.build
+    end
+    attr_writer :run
+
+    def random
+      @random ||= Random::Substitute.build
+    end
+    attr_writer :random
+
+    def initialize(*arguments)
+      @arguments = arguments
+    end
+
+    def self.build(arguments=nil, env: nil)
+      arguments ||= ::ARGV
+      env ||= ::ENV
+
+      instance = new(*arguments)
+      instance.env = env
+      Output::Writer.configure(instance)
+      Run.configure(instance)
+      instance
+    end
+
+    def self.call(arguments=nil, env: nil)
+      instance = build(arguments, env:)
+
+      session = instance.run.session
+      Session::Store.reset(session)
+
+      instance.()
+    end
+
+    def call
+      parse_arguments
+
+      if exit_code?
+        return exit_code
       end
 
-      Run.(exclude: exclude_file_pattern) do |run|
-        if read_stdin
-          until $stdin.eof?
-            path = $stdin.gets.chomp
+      writer.puts(RUBY_DESCRIPTION)
+      writer.puts("Random Seed: #{random.seed.to_s(36)}")
+      writer.puts
+
+      default_path = Defaults.tests_directory
+
+      result = run.! do |run|
+        if not stdin.tty?
+          until stdin.eof?
+            path = stdin.gets(chomp: true)
 
             next if path.empty?
 
-            run.path(path)
+            run << path
           end
         end
 
-        if path_arguments.empty?
-          unless read_stdin
-            run.path(tests_directory)
+        arguments.each do |path|
+          run << path
+        end
+
+        if not run.ran?
+          run << default_path
+        end
+      end
+
+      self.exit_code = self.class.exit_code(result)
+
+      exit_code
+    end
+
+    def parse_arguments
+      argument_index = 0
+
+      until argument_index == arguments.count
+        next_argument = next_argument(argument_index)
+
+        if not next_argument.start_with?('-')
+          argument_index += 1
+          next
+        end
+
+        switch = next_argument!(argument_index)
+
+        case switch
+        when '--'
+          break
+
+        when '-h', '--help'
+          print_help_text
+
+          self.exit_code = 0
+
+        when '-v', '--version'
+          writer.puts "TestBench Version: #{version}"
+
+          self.exit_code = 0
+
+        when '-d', '--detail', '--no-detail'
+          if not negated?(switch)
+            detail_policy_text = 'on'
+          else
+            detail_policy_text = 'off'
           end
-        else
-          path_arguments.each do |path|
-            run.path(path)
+
+          detail_policy = detail_policy_text.to_sym
+          Session::Output::Detail.assure_detail(detail_policy)
+
+          env['TEST_BENCH_DETAIL'] = detail_policy_text
+
+        when '-x', '--exclude', '--no-exclude'
+          if not negated?(switch)
+            exclude_file_pattern_text = switch_value!(argument_index, switch)
+          else
+            exclude_file_pattern_text = ''
+          end
+
+          env['TEST_BENCH_EXCLUDE_FILE_PATTERN'] = exclude_file_pattern_text
+
+        when '-f', '--only-failure', '--no-only-failure'
+          if not negated?(switch)
+            only_failure_text = 'on'
+          else
+            only_failure_text = 'off'
+          end
+
+          env['TEST_BENCH_ONLY_FAILURE'] = only_failure_text
+
+        when '-o', '--output-styling'
+          output_styling_text = switch_value(argument_index) do
+            'on'
           end
+
+          output_styling = output_styling_text.to_sym
+          Output::Writer::Styling.assure_styling(output_styling)
+
+          env['TEST_BENCH_OUTPUT_STYLING'] = output_styling_text
+
+        when '-s', '--seed'
+          seed_text = switch_value!(argument_index, switch)
+
+          begin
+            Integer(seed_text)
+          rescue
+            raise ArgumentError, "Seed switch must be an integer (Seed: #{seed_text.inspect})"
+          end
+
+          env['TEST_BENCH_SEED'] = seed_text
+
+        when '-r', '--require'
+          library = switch_value!(argument_index, switch)
+
+          require library
+
+        else
+          raise ArgumentError, "Unknown switch #{switch.inspect}"
         end
       end
     end
 
+    def print_help_text
+      writer.write <<~TEXT
+      Usage: #{program_name} [options] [paths]
+
+      Informational Options:
+      \t-h, --help                        Print this help message and exit successfully
+      \t-v, --version                     Print version and exit successfully
+
+      Configuration Options:
+      \t-d, --[no]detail                  Always show (or hide) details (Default: #{Session::Output::Detail.default})
+      \t-x, --[no-]exclude PATTERN        Do not execute test files matching PATTERN (Default: #{Run::GetFiles::Defaults.exclude_file_pattern.inspect})
+      \t-f, --[no-]only-failure           Don't display output for test files that pass (Default: #{Run::Output::File::Defaults.only_failure ? 'on' : 'off'})
+      \t-o, --output-styling [on|off|detect]
+      \t                                  Render output coloring and font styling escape codes (Default: #{Output::Writer::Styling.default})
+      \t-s, --seed NUMBER                 Sets pseudo-random number seed (Default: not set)
+
+      Other Options:
+      \t-r, --require LIBRARY             Require LIBRARY before running any files
+
+      Paths to test files (and directories containing test files) can be given after any command line arguments or via STDIN (or both).
+
+      If no paths are given, a default path (#{Defaults.tests_directory}) is scanned for test files.
+
+      The following environment variables can also control execution:
+
+      \tTEST_BENCH_DETAIL                 Same as -d or --detail
+      \tTEST_BENCH_EXCLUDE_FILE_PATTERN   Same as -x or --exclude-file-pattern
+      \tTEST_BENCH_ONLY_FAILURE           Same as -f or --only-failure
+      \tTEST_BENCH_OUTPUT_STYLING         Same as -o or --output-styling
+      \tTEST_BENCH_SEED                   Same as -s or --seed
+
+      TEXT
+    end
+
+    def negated?(switch)
+      switch.start_with?('--no-')
+    end
+
+    def exit_code?
+      !exit_code.nil?
+    end
+
+    def switch_value!(argument_index, argument)
+      switch_value(argument_index) do
+        raise ArgumentError, "Argument #{argument.inspect} requires an argument"
+      end
+    end
+
+    def switch_value(argument_index, &no_value_action)
+      next_value = next_argument(argument_index)
+
+      if next_value.nil? || next_value.start_with?('-')
+        switch_value = nil
+
+        return no_value_action.()
+      else
+        switch_value = next_argument!(argument_index)
+
+        return switch_value
+      end
+    end
+
+    def next_argument(argument_index)
+      arguments[argument_index]
+    end
+
+    def next_argument!(argument_index)
+      arguments.delete_at(argument_index)
+    end
+
+    def self.exit_code(result)
+      if result == true
+        0
+      elsif result == false
+        1
+      else
+        2
+      end
+    end
+
     module Defaults
       def self.tests_directory
         ENV.fetch('TEST_BENCH_TESTS_DIRECTORY', 'test/automated')
       end
+
+      def self.program_name
+        $PROGRAM_NAME || 'bench'
+      end
+
+      def self.version
+        if Object.const_defined?(:Gem)
+          spec = Gem.loaded_specs['test_bench']
+        end
+
+        spec&.version || '(unknown)'
+      end
     end
   end
 end

data/lib/test_bench/controls/file.rb

@@ -0,0 +1,5 @@
+module TestBench
+  module Controls
+    File = Run::Controls::File
+  end
+end

data/lib/test_bench/controls/path.rb

@@ -1,15 +1,5 @@
 module TestBench
   module Controls
-    module Path
-      def self.example
-        TestFile.filename
-      end
-
-      def self.alternate
-        TestFile::Alternate.filename
-      end
-
-      Directory = Controls::Directory
-    end
+    Path = Run::Controls::Path
   end
 end

data/lib/test_bench/controls/random.rb

@@ -0,0 +1,7 @@
+module TestBench
+  module Controls
+    module Random
+      Seed = TestBench::Random::Controls::Seed
+    end
+  end
+end

data/lib/test_bench/controls/result.rb

@@ -1,5 +1,5 @@
 module TestBench
   module Controls
-    Result = TestBench::Fixture::Controls::Result
+    Result = Run::Controls::Result
   end
 end

data/lib/test_bench/controls/stdin.rb

@@ -0,0 +1,27 @@
+module TestBench
+  module Controls
+    module Stdin
+      module Create
+        def self.call(*paths)
+          if paths.empty?
+            paths = Path.examples
+          end
+
+          contents = <<~TEXT
+          #{paths.join("\n")}
+          TEXT
+
+          file = File::Create.(contents:)
+
+          ::File.open(file, 'r')
+        end
+
+        def self.contents
+          <<~TEXT
+          #{Path.example}
+          TEXT
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/controls.rb

@@ -1,28 +1,11 @@
-unless RUBY_ENGINE == 'mruby'
-  require 'securerandom'
-end
+require 'test_bench/random/controls'
+require 'test_bench/run/controls'
 
-require 'test_bench/fixture/controls'
+require 'test_bench/controls/result'
 
-require 'test_bench/controls/caller_location'
-require 'test_bench/controls/depth'
-require 'test_bench/controls/device'
-require 'test_bench/controls/directory'
-require 'test_bench/controls/error'
-require 'test_bench/controls/fixture'
 require 'test_bench/controls/path'
-require 'test_bench/controls/pattern'
-require 'test_bench/controls/result'
-require 'test_bench/controls/test_file'
-require 'test_bench/controls/time'
 
-require 'test_bench/controls/output/escape_code'
-require 'test_bench/controls/output/newline_character'
-require 'test_bench/controls/output/styling'
-require 'test_bench/controls/output/print_error'
-require 'test_bench/controls/output/exercise'
-require 'test_bench/controls/output/summary/session'
-require 'test_bench/controls/output/summary/error'
-require 'test_bench/controls/output/batch_data'
-require 'test_bench/controls/output/detail_setting'
-require 'test_bench/controls/output/log_level'
+require 'test_bench/controls/file'
+require 'test_bench/controls/stdin'
+
+require 'test_bench/controls/random'

data/lib/test_bench/test_bench.rb

@@ -1,104 +1,50 @@
 module TestBench
-  def self.session
-    @session ||= build_session.tap do |session|
-      at_exit do
-        exit_code = exit_code(session)
-
-        exit(exit_code) unless exit_code.zero?
-      end
-    end
-  end
-  singleton_class.attr_writer(:session)
-
-  def self.output
-    session.output
-  end
-
-  def self.set_output(output, session: nil)
-    session ||= self.session
-
-    if output.is_a?(Array)
-      output = Fixture::Output::Multiple.build(*output)
-    end
-
-    session.output = output
-  end
-  singleton_class.alias_method :output=, :set_output
-
-  def self.activate(receiver=nil, session: nil)
+  def self.activate(receiver=nil, session_store: nil)
     receiver ||= TOPLEVEL_BINDING.receiver
+    session_store ||= Session::Store.instance
 
-    fixture(session, receiver: receiver)
-  end
-
-  def self.evaluate(session: nil, &block)
-    fixture = fixture(session)
+    receiver.extend(Fixture)
+    receiver.extend(DeactivatedVariants)
 
-    fixture.context do
-      fixture.instance_exec(&block)
-    end
+    receiver.extend(TestSession)
+    receiver.test_session_store = session_store
   end
 
   def self.context(title=nil, session: nil, &block)
-    evaluate(session: session) do
+    evaluate(session:) do
       context(title) do
         instance_exec(&block)
       end
     end
   end
 
-  def self.fixture(session=nil, receiver: nil)
-    session ||= self.session
-    receiver ||= Object.new
-
-    receiver.extend(Fixture)
-    receiver.extend(DeactivationVariants)
-
-    receiver.test_session = session
-
-    receiver
-  end
-
-  def self.build_session(output: nil, abort_on_error: nil, **args)
-    output ||= Output.build
-    error_policy = session_error_policy(abort_on_error)
+  def self.evaluate(session: nil, &block)
+    fixture = TestBench::Fixture::Evaluate.build(session:, &block)
+    fixture.extend(DeactivatedVariants)
+    fixture.()
 
-    Fixture::Session.build(output: output, error_policy: error_policy, **args)
+    fixture.test_session.passed?
   end
 
-  def self.session_error_policy(abort_on_error=nil)
-    abort_on_error = Defaults.abort_on_error if abort_on_error.nil?
-
-    if abort_on_error
-      :abort
-    else
-      :rescue
-    end
+  def self.session
+    Session::Store.get
   end
 
-  def self.exit_code(session, fail_deactivated_tests: nil)
-    if fail_deactivated_tests.nil?
-      fail_deactivated_tests = Defaults.fail_deactivated_tests
+  module DeactivatedVariants
+    def _context(title=nil, &)
+      context(title)
     end
 
-    if session.failed?
-      1
-    elsif session.skipped?
-      fail_deactivated_tests ? 2 : 0
-    else
-      0
+    def _test(title=nil, &)
+      test(title)
     end
   end
 
-  Session = Fixture::Session
-
-  module Defaults
-    def self.abort_on_error
-      Environment::Boolean.fetch('TEST_BENCH_ABORT_ON_ERROR', false)
-    end
+  module TestSession
+    attr_accessor :test_session_store
 
-    def self.fail_deactivated_tests
-      Environment::Boolean.fetch('TEST_BENCH_FAIL_DEACTIVATED_TESTS', true)
+    def test_session
+      test_session_store.fetch
     end
   end
 end

data/lib/test_bench.rb

@@ -1,39 +1,5 @@
-unless RUBY_ENGINE == 'mruby'
-  require 'optionparser'
-end
-
-require 'test_bench/fixture'
-
-require 'test_bench/environment/boolean'
-
-require 'test_bench/output/writer'
-require 'test_bench/output/writer/sgr'
-require 'test_bench/output/writer/substitute'
-require 'test_bench/output/writer/dependency'
-
-require 'test_bench/output/timer'
-require 'test_bench/output/timer/substitute'
-
-require 'test_bench/output/print_error'
-
-require 'test_bench/output/summary'
-require 'test_bench/output/summary/session'
-
-require 'test_bench/output/batch_data'
-
-require 'test_bench/output/raw'
-
-require 'test_bench/output/buffer'
-
-require 'test_bench/output/log'
-
-require 'test_bench/output'
+require 'test_bench/run'
 
 require 'test_bench/test_bench'
-require 'test_bench/deactivation_variants'
-
-require 'test_bench/run'
-require 'test_bench/run/substitute'
 
-require 'test_bench/cli/parse_arguments'
 require 'test_bench/cli'

data/script/bench

@@ -1,19 +1,5 @@
 #!/usr/bin/env ruby
 
-begin
-  require 'test_bench'
-rescue LoadError => load_error
-end
-
-unless load_error.nil?
-  if File.exist?('init.rb')
-    require_relative '../init.rb'
-    require 'test_bench'
-
-    ENV['BOOTSTRAP'] ||= 'off'
-  else
-    raise load_error
-  end
-end
+require 'test_bench'
 
 TestBench::CLI.()