test_bench-isolated 0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2f36ae682bd15d3af0f189c7df3337bcdf5acf84e8e809ce2f05d273a5d8129a
+  data.tar.gz: 42d939f0f13bde2fe3808a9dfbbe4415c9026480bf6fa0f90b977682615f8274
+SHA512:
+  metadata.gz: 35eb7d285e7d39f4b690191053915a347062d60d40e659080329a582ef7d85ddbea59342085ca4b3b0fbb849482739c33a77fd281216b1ef60255fe6abc6e605
+  data.tar.gz: 1c3da22303afc2fc9f674381edb53de250b4e4746afdeef47952ebe2cad13b7e4aceb8821eb8a841b9bb58ffc6da6502e73f00cb09b5d2c1c9f79a73171adb4f

data/lib/test_bench/bootstrap.rb

@@ -0,0 +1,328 @@
+module TestBench
+  module Bootstrap
+    def self.activate
+      Object.include(Fixture)
+    end
+
+    module Backtrace
+      if RUBY_ENGINE != 'mruby'
+        def self.frame(frame_index)
+          frame_index += 1
+
+          caller[frame_index]
+        end
+      end
+    end
+
+    class AssertionFailure < RuntimeError
+      def self.build(frame_index=nil)
+        frame_index ||= 0
+
+        frame = Backtrace.frame(frame_index)
+
+        instance = new
+        instance.set_backtrace([frame])
+        instance
+      end
+
+      def message
+        "Assertion failed"
+      end
+    end
+
+    module Path
+      if RUBY_ENGINE != 'mruby'
+        def self.match?(pattern, string)
+          ::File.fnmatch?(pattern, string)
+        end
+
+        def self.search(path, include_pattern=nil, exclude_pattern=nil)
+          files = []
+
+          if ::File.directory?(path)
+            search_directory(path, files, include_pattern, exclude_pattern)
+          elsif ::File.exist?(path)
+            files << path
+          else
+            raise LoadError, "no such file or directory -- #{path}"
+          end
+
+          files
+        end
+
+        def self.search_directory(dir, files, include_pattern=nil, exclude_pattern=nil)
+          include_pattern ||= '*.rb'
+
+          ::Dir[::File.join(dir, '**', '*')].each do |path|
+            next if ::File.directory?(path)
+
+            if match?(include_pattern, path)
+              if exclude_pattern.nil? || !match?(exclude_pattern, path)
+                files << path
+              end
+            end
+          end
+        end
+      end
+    end
+
+    module Fixture
+      def assert(value)
+        unless value
+          raise AssertionFailure.build(1)
+        end
+      end
+
+      def assert_raises(error_class=nil, &block)
+        begin
+          block.()
+
+        rescue (error_class || StandardError) => error
+          return if error_class.nil?
+
+          if error.instance_of?(error_class)
+            return
+          else
+            raise error
+          end
+        end
+
+        raise AssertionFailure.build(1)
+      end
+
+      def refute(value)
+        if value
+          raise AssertionFailure.build(1)
+        end
+      end
+
+      def refute_raises(error_class=nil, &block)
+        block.()
+
+      rescue (error_class || StandardError) => error
+        unless error.instance_of?(error_class)
+          raise error
+        end
+
+        raise AssertionFailure.build(1)
+      end
+
+      def context(title=nil, &block)
+        if block.nil?
+          Output.write(title || 'Context', sgr_code: 0x33)
+          return
+        end
+
+        unless title.nil?
+          Output.indent(title, sgr_code: 0x32) do
+            context(&block)
+          end
+          return
+        end
+
+        block.()
+      end
+      alias_method :context!, :context
+
+      def _context(title=nil, &block)
+        context(title)
+      end
+
+      def test(title=nil, &block)
+        if block.nil?
+          Output.write(title || 'Test', sgr_code: 0x33)
+          return
+        end
+
+        begin
+          block.()
+
+          Output.indent(title, sgr_code: 0x32)
+
+        rescue => error
+          Output.indent(title || 'Test', sgr_codes: [0x1, 0x31])
+
+          raise error
+        end
+      end
+      alias_method :test!, :test
+
+      def _test(title=nil, &block)
+        test(title)
+      end
+
+      def comment(...)
+        detail(...)
+      end
+
+      def detail(detail, *additional_details, quote: nil, heading: nil)
+        details = [detail, *additional_details]
+
+        if quote.nil?
+          if additional_details == ['']
+            quote = true
+          else
+            quote = details.last.end_with?("\n")
+          end
+        end
+
+        if quote
+          if heading.nil?
+            heading = !detail.end_with?("\n")
+          end
+        end
+
+        if heading
+          heading_text = details.shift
+          Output.indent(heading_text, sgr_codes: [0x1, 0x4])
+        end
+
+        details.each do |detail|
+          if detail.empty?
+            Output.indent("\e[2;3m(empty)\e[23;22m")
+            next
+          end
+
+          if quote
+            detail.each_line do |line|
+              line.chomp!
+
+              Output.indent("\e[2m> \e[22m#{line}")
+            end
+          else
+            Output.indent(detail)
+          end
+        end
+      end
+
+      def fixture(cls, *args, **kwargs, &block)
+        fixture = TestBench::Fixture.(cls, *args, **kwargs, &block)
+
+        passed = !fixture.test_session.failed?
+
+        assert(passed)
+      end
+    end
+
+    module Output
+      extend self
+
+      def write(text, device: nil, sgr_code: nil, sgr_codes: nil, tab_indent: nil)
+        indent(text, device: device, sgr_code: sgr_code, sgr_codes: sgr_codes, tab_indent: tab_indent)
+      end
+
+      def newline
+        write('')
+      end
+
+      def indent(text, device: nil, sgr_code: nil, sgr_codes: nil, tab_indent: nil, &block)
+        unless text.nil?
+          sgr_codes ||= []
+          unless sgr_code.nil?
+            sgr_codes << sgr_code
+          end
+
+          unless sgr_codes.empty?
+            sgr_codes.map! do |sgr_code|
+              sgr_code.to_s(16)
+            end
+
+            text = "\e[#{sgr_codes.join(';')}m#{text}\e[0m"
+          end
+
+          text = "#{"\t" if tab_indent}#{'  ' * indentation}#{text}\n"
+
+          raw_write(text, device)
+        end
+
+        return if block.nil?
+
+        self.indentation += 1 unless text.nil?
+
+        begin
+          block.()
+        ensure
+          self.indentation -= 1 unless text.nil?
+        end
+      end
+
+      def raw_write(text, device=nil)
+        device ||= self.device
+
+        device.write(text)
+      end
+
+      def indentation
+        @indentation ||= 0
+      end
+      attr_writer :indentation
+
+      def device
+        @device ||= Defaults.output_device
+      end
+    end
+
+    module Run
+      def self.call(paths=nil, exclude_pattern: nil)
+        paths ||= []
+        exclude_pattern ||= Defaults.exclude_file_pattern
+
+        if paths.is_a?(String)
+          paths = [paths]
+        end
+
+        if paths.empty?
+          paths << Defaults.tests_dir
+        end
+
+        paths.each do |path|
+          Path.search(path, '*.rb', exclude_pattern).each do |file|
+            Output.write "Running #{file}"
+
+            begin
+              load(file)
+            ensure
+              Output.newline
+            end
+          end
+        end
+      end
+    end
+
+    module Defaults
+      def self.get(env_var, default)
+        if env.key?(env_var)
+          env[env_var]
+        else
+          default
+        end
+      end
+
+      def self.exclude_file_pattern
+        get('TEST_BENCH_EXCLUDE_FILE_PATTERN', '*_init.rb')
+      end
+
+      def self.omit_backtrace_pattern
+        get('TEST_BENCH_OMIT_BACKTRACE_PATTERN', '*/test_bench/bootstrap.rb')
+      end
+
+      def self.tests_dir
+        get('TEST_BENCH_TESTS_DIRECTORY', 'test/automated')
+      end
+
+      if RUBY_ENGINE == 'mruby'
+        def self.env
+          {}
+        end
+      else
+        def self.output_device
+          $stdout
+        end
+
+        def self.env
+          ::ENV
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,43 @@
+--- !ruby/object:Gem::Specification
+name: test_bench-isolated
+version: !ruby/object:Gem::Version
+  version: '0'
+platform: ruby
+authors:
+- Nathan Ladd
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-07-24 00:00:00.000000000 Z
+dependencies: []
+description:
+email: nathanladd+github@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/test_bench/bootstrap.rb
+homepage: https://github.com/test-bench/test-bench-bootstrap
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: A minimal test framework for testing TestBench
+test_files: []