test_bench-isolated 0 → 2.0.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f36ae682bd15d3af0f189c7df3337bcdf5acf84e8e809ce2f05d273a5d8129a
-  data.tar.gz: 42d939f0f13bde2fe3808a9dfbbe4415c9026480bf6fa0f90b977682615f8274
+  metadata.gz: f481a604aa280b59333588ed3473d30c0ca272f732133952a54ee2d833914fad
+  data.tar.gz: 3aa29f7077ea35970b3e263bee0d6cff7dfd00f2221d39bb491cfebcfecef260
 SHA512:
-  metadata.gz: 35eb7d285e7d39f4b690191053915a347062d60d40e659080329a582ef7d85ddbea59342085ca4b3b0fbb849482739c33a77fd281216b1ef60255fe6abc6e605
-  data.tar.gz: 1c3da22303afc2fc9f674381edb53de250b4e4746afdeef47952ebe2cad13b7e4aceb8821eb8a841b9bb58ffc6da6502e73f00cb09b5d2c1c9f79a73171adb4f
+  metadata.gz: b482e2e30289919565e2a2995809ee8c188cc20be58985bc2ff7e53721866c02376f3bdb480211de1ce3b691c97e5ed543a7a101b6f4e8d11759f6c6ce3d15f1
+  data.tar.gz: 119daa3855015ce6d2de5438cf99f70f8969dc0f96c21d8a644f9844b05572d8b23590bfa6c05d96ca4edf3e0073d1f5d31cee7a246465416f156f2069457ace

data/lib/test_bench_isolated/test_bench/cli.rb

@@ -0,0 +1,298 @@
+module TestBenchIsolated
+  module TestBench
+    class CLI
+      ArgumentError = Class.new(RuntimeError)
+  
+      attr_reader :arguments
+  
+      attr_accessor :exit_code
+  
+      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)
+        Random.configure(instance)
+        instance
+      end
+  
+      def self.call(arguments=nil, env: nil)
+        instance = build(arguments, env:)
+  
+        session = instance.run.session
+        Session::Store.reset(session)
+  
+        exit_code = instance.()
+  
+        exit(exit_code)
+      end
+  
+      def call
+        parse_arguments
+  
+        if exit_code?
+          return exit_code
+        end
+  
+        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
+            end
+          end
+  
+          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
+  
+            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
+end

data/lib/test_bench_isolated/test_bench/controls/file.rb

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

data/lib/test_bench_isolated/test_bench/controls/path.rb

@@ -0,0 +1,7 @@
+module TestBenchIsolated
+  module TestBench
+    module Controls
+      Path = Run::Controls::Path
+    end
+  end
+end

data/lib/test_bench_isolated/test_bench/controls/random.rb

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

data/lib/test_bench_isolated/test_bench/controls/result.rb

@@ -0,0 +1,7 @@
+module TestBenchIsolated
+  module TestBench
+    module Controls
+      Result = Run::Controls::Result
+    end
+  end
+end

data/lib/test_bench_isolated/test_bench/controls/stdin.rb

@@ -0,0 +1,29 @@
+module TestBenchIsolated
+  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
+end

data/lib/test_bench_isolated/test_bench/controls.rb

@@ -0,0 +1,11 @@
+require 'test_bench_isolated/test_bench/random/controls'
+require 'test_bench_isolated/test_bench/run/controls'
+
+require 'test_bench_isolated/test_bench/controls/result'
+
+require 'test_bench_isolated/test_bench/controls/path'
+
+require 'test_bench_isolated/test_bench/controls/file'
+require 'test_bench_isolated/test_bench/controls/stdin'
+
+require 'test_bench_isolated/test_bench/controls/random'

data/lib/test_bench_isolated/test_bench/fixture/actuate/class.rb

@@ -0,0 +1,97 @@
+module TestBenchIsolated
+  module TestBench
+    module Fixture
+      module Actuate
+        module Class
+          Error = ::Class.new(RuntimeError)
+  
+          def self.call(fixture_class, *, session: nil, **, &block)
+            if test_block?(fixture_class)
+              test_block = block
+            else
+              block_actuator = block
+            end
+  
+            fixture = build_fixture(fixture_class, *, **, &test_block)
+  
+            Session.configure(fixture, session:, attr_name: :test_session)
+  
+            actuate(fixture, &block_actuator)
+  
+            fixture
+          end
+  
+          def self.actuate(fixture, &block_actuator)
+            if fixture.respond_to?(:call)
+              fixture_actuator = fixture
+            end
+  
+            if block_actuator && fixture_actuator
+              raise Error, "Block argument given to fixture that has an actuator (Fixture Class: #{fixture.class})"
+            end
+  
+            if block_actuator.nil? && fixture_actuator.nil?
+              raise Error, "No actuator"
+            end
+  
+            if not block_actuator.nil?
+              block_actuator.(fixture)
+            else
+              fixture_actuator.()
+            end
+          end
+  
+          def self.build_fixture(fixture_class, ...)
+            constructor = constructor(fixture_class)
+  
+            fixture_class.public_send(constructor, ...)
+          end
+  
+          def self.test_block?(fixture_class)
+            assure_fixture(fixture_class)
+  
+            constructor = constructor(fixture_class)
+  
+            if constructor == :build
+              constructor_method = fixture_class.method(:build)
+            else
+              constructor_method = fixture_class.instance_method(:initialize)
+            end
+  
+            constructor_parameters = constructor_method.parameters
+  
+            constructor_parameters.any? do |(type, _)|
+              type == :block
+            end
+          end
+  
+          def self.constructor(fixture_class)
+            assure_fixture(fixture_class)
+  
+            if fixture_class.respond_to?(:build)
+              :build
+            else
+              :new
+            end
+          end
+  
+          def self.assure_fixture(fixture_class)
+            is_class = fixture_class.instance_of?(::Class)
+  
+            if not is_class
+              raise Error, "Not a class (Class: #{fixture_class})"
+            end
+  
+            if is_class
+              is_fixture_class = fixture_class.included_modules.include?(Fixture)
+            end
+  
+            if not is_fixture_class
+              raise Error, "Not a fixture class (Class: #{fixture_class})"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench_isolated/test_bench/fixture/actuate/object.rb

@@ -0,0 +1,93 @@
+module TestBenchIsolated
+  module TestBench
+    module Fixture
+      module Actuate
+        module Object
+          ModuleError = ::Class.new(RuntimeError)
+  
+          def self.call(object, *modules, session: nil, &block_actuator)
+            extend(object, *modules)
+  
+            Session.configure(object, session:, attr_name: :test_session)
+  
+            block_actuator.(object)
+          end
+  
+          def self.extend(object, *modules)
+            if modules.empty?
+              fixture_modules = fixture_modules(object)
+            else
+              fixture_modules = modules.map do |mod|
+                assure_included(object, mod)
+  
+                fixture_module(mod)
+              end
+            end
+  
+            if fixture_modules.empty?
+              raise ModuleError, "No Fixture modules found -- #{object.inspect}"
+            end
+  
+            fixture_modules.each do |fixture_module|
+              object.extend(fixture_module)
+            end
+  
+            object.extend(Fixture)
+          end
+  
+          def self.assure_included(object, mod)
+            if not object.is_a?(mod)
+              raise ModuleError, "Object doesn't include module -- #{mod.inspect}"
+            end
+          end
+  
+          def self.fixture_modules(object)
+            fixture_modules = []
+  
+            targets = included_modules(object)
+  
+            targets << object
+  
+            targets.select do |target|
+              if fixture_module?(target)
+                fixture_module = fixture_module(target)
+                fixture_modules << fixture_module
+              end
+            end
+  
+            fixture_modules
+          end
+  
+          def self.fixture_module(object)
+            if not fixture_module?(object)
+              raise ModuleError, "Couldn't resolve a Fixture module -- #{object.inspect}"
+            end
+  
+            target = fixture_module_target(object)
+  
+            target.const_get(:Fixture, false)
+          end
+  
+          def self.fixture_module?(object)
+            target = fixture_module_target(object)
+  
+            target.const_defined?(:Fixture, false)
+          end
+  
+          def self.fixture_module_target(object)
+            if object.is_a?(Module)
+              object
+            else
+              object.class
+            end
+          end
+  
+          def self.included_modules(object)
+            modules = (object.class.included_modules | object.singleton_class.included_modules) - ::Object.included_modules
+            modules.sort_by(&:name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench_isolated/test_bench/fixture/controls/exception.rb

@@ -0,0 +1,9 @@
+module TestBenchIsolated
+  module TestBench
+    module Fixture
+      module Controls
+        Exception = TestBench::Session::Controls::Exception
+      end
+    end
+  end
+end

data/lib/test_bench_isolated/test_bench/fixture/controls/fixture/class.rb

@@ -0,0 +1,88 @@
+module TestBenchIsolated
+  module TestBench
+    module Fixture
+      module Controls
+        module Fixture
+          module Class
+            Example = Fixture::Example
+  
+            class BuildMethod
+              include TestBench::Fixture
+  
+              attr_accessor :some_argument
+              attr_accessor :some_keyword_argument
+  
+              def self.build(some_argument=nil, some_keyword_argument: nil)
+                instance = new
+                instance.some_argument = some_argument
+                instance.some_keyword_argument = some_keyword_argument
+                instance
+              end
+            end
+  
+            class NoBuildMethod
+              include TestBench::Fixture
+  
+              attr_reader :some_argument
+              attr_reader :some_keyword_argument
+  
+              def initialize(some_argument=nil, some_keyword_argument: nil)
+                @some_argument = some_argument
+                @some_keyword_argument = some_keyword_argument
+              end
+            end
+  
+            class TestBlock
+              include TestBench::Fixture
+  
+              attr_reader :test_block
+  
+              def initialize(&test_block)
+                @test_block = test_block
+              end
+  
+              NoBuildMethod = TestBlock
+  
+              class BuildMethod
+                include TestBench::Fixture
+  
+                attr_reader :test_block
+  
+                def initialize(test_block)
+                  @test_block = test_block
+                end
+  
+                def self.build(&test_block)
+                  new(test_block)
+                end
+              end
+  
+              None = Fixture::Class::BuildMethod
+            end
+  
+            class Actuator
+              include TestBench::Fixture
+  
+              attr_accessor :actuated
+              def actuated? = !!actuated
+  
+              def call
+                self.actuated = true
+              end
+  
+              class TestBlock < Actuator
+                attr_reader :test_block
+  
+                def initialize(&test_block)
+                  @test_block = test_block
+                end
+              end
+            end
+  
+            NoActuator = Example
+          end
+        end
+      end
+    end
+  end
+end