spinel_test-unit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c2341cde71f3bee22ab32ced8d1a7db330bfbbc77dccec006bb9acfc7965c2cb
+  data.tar.gz: dd0e9c94e0839a62409c8406999bcf11fa60f6b3aec7e2d04ada67e537cc59a3
+SHA512:
+  metadata.gz: bec8fd80b6355b89a98d4972390468639e7e2cb93a6e7643dd323cb8ffe0b9c006d537d428f62a2b60ecfafb2fd892e56b5047fa7c6c6778fb2fa900285effb3
+  data.tar.gz: 561053edd31dc9783b69afadefaea5299b0d74d8765f2597a8dde7bd42f404f5afb83c640e401d9ce49e048df2dfee7a0b4d16093fe881221e7748f521cb80c3

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"spinel_test-unit" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["yuuji.yaginuma@gmail.com"](mailto:"yuuji.yaginuma@gmail.com").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yuji Yaginuma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,90 @@
+# SpinelTest::Unit
+
+An xUnit-style test framework for [Spinel](https://github.com/matz/spinel).
+
+## Installation
+
+Add it to your Gemfile:
+
+```ruby
+gem "spinel_test-unit"
+```
+
+Spinel itself is found through, in order: the `SPINEL` environment variable,
+`spinel` on `PATH`, `mise which spinel`.
+
+## Usage
+
+```ruby
+# test/calc_test.rb
+require "spinel_test/unit"
+require "calc"
+
+class CalcTest < SpinelTest::Unit::TestCase
+  def setup
+    @calc = Calc.new
+  end
+
+  def test_add
+    assert @calc.add(1, 2) == 3
+  end
+
+  def test_failure_message
+    assert @calc.add(1, 1) == 2, "1 + 1 should be 2"
+  end
+end
+```
+
+```console
+$ bundle exec spinel_test-unit                 # test/**/*_test.rb and test/**/test_*.rb
+$ bundle exec spinel_test-unit test/calc_test.rb
+$ bundle exec spinel_test-unit -n test_add     # only tests whose "Class#method" name includes it
+```
+
+Output:
+
+```
+..F
+
+Failure: CalcTest#test_failure_message
+1 + 1 should be 2
+
+3 tests, 3 assertions, 1 failures, 0 errors
+```
+
+Available assertions:
+
+- `assert(test, message = nil)`
+- `assert_equal(expected, actual, message = nil)`
+- `assert_nil(value, message = nil)`
+- `assert_includes(collection, item, message = nil)`
+- `assert_raise(klass) { ... }` (passes for `klass` or a subclass; returns the exception; assertion failures raised inside the block propagate)
+
+`setup` and `teardown` hooks are supported.
+
+## Constraints (from Spinel)
+
+- Test code must be compilable by Spinel: no `send` with dynamic names,
+  `define_method`, `instance_methods`, etc. in tests or in the code under test.
+- Test classes must be defined as literal `class FooTest < SpinelTest::Unit::TestCase`
+  (or a literal subclass of another test class) with literal `def test_*`.
+  Tests are never generated by metaprogramming.
+- A base test class may live in a library on an `-I` path: `require` /
+  `require_relative` with string literals are followed transitively from the
+  test files, and those files are scanned (not run) to resolve superclasses.
+  Only classes in the target test files are run.
+- Files are loaded with `require` and the load paths `lib`, `test` and the
+  project root; use `require "..."` / `require_relative` that Spinel resolves.
+- Test files under `fixtures/` directories (relative to the project root) are skipped unless named explicitly or the given directory is itself inside `fixtures/`.
+- `ScriptError`s (such as `NotImplementedError`) raised by a test are reported as errors; a teardown error after a failure is appended to its message.
+
+## Development
+
+Run `bin/setup` (installs Spinel with [mise](https://mise.jdx.dev/) and the
+gems), then `bundle exec rake test`. The tests use test-unit; the end-to-end
+tests are skipped when Spinel is not available. To use a Spinel checkout, set
+`SPINEL` in a git-ignored `mise.local.toml`.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test" << "lib"
+  t.test_files = FileList["test/**/*_test.rb", "test/**/test_*.rb"].exclude("test/fixtures/**/*")
+end
+
+task default: :test

data/exe/spinel_test-unit

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "spinel_test/unit/cli"
+
+exit SpinelTest::Unit::CLI.start(ARGV)

data/lib/spinel_test/unit/cli.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+require "tmpdir"
+require_relative "scanner"
+require_relative "generator"
+require_relative "toolchain"
+
+module SpinelTest
+  module Unit
+    # spinel_test-unit [PATH...] [-n NAME]
+    #
+    # Scans the test files with Prism, generates a main.rb that calls every
+    # test, compiles it with Spinel and runs the binary.
+    class CLI
+      def self.start(argv, root: Dir.pwd)
+        new(argv, root: root).run
+      end
+
+      def initialize(argv, root: Dir.pwd)
+        @root = File.expand_path(root)
+        @paths = []
+        @filter = nil
+        @keep = false
+        @includes = []
+        @exit = nil
+        parse(argv.dup)
+      end
+
+      USAGE = <<~TEXT
+        Usage: spinel_test-unit [PATH...] [-n NAME] [-I DIR]
+
+        Compiles the tests with Spinel and runs them.
+
+          PATH             test file or directory (default: test)
+          -n, --name NAME  run only the tests whose "Class#test_name" includes NAME
+          -I DIR           add DIR to Spinel's load path (repeatable)
+          -h, --help       show this help
+      TEXT
+
+      def run
+        return @exit if @exit
+
+        files = test_files
+        if files.empty?
+          warn "spinel_test-unit: no test files found"
+          return 1
+        end
+
+        spinel = Toolchain.spinel
+        unless spinel
+          warn "spinel_test-unit: Spinel not found (set SPINEL, put spinel on PATH, or install it with mise)"
+          return 1
+        end
+
+        entries = build_entries(files)
+        if entries.empty?
+          warn "spinel_test-unit: no tests found"
+          return 1
+        end
+
+        Dir.mktmpdir("spinel_test-unit") do |dir|
+          main = File.join(dir, "main.rb")
+          bin = File.join(dir, "testbin")
+          File.write(main, Generator.generate(entries))
+          return 1 unless compile(spinel, main, bin, entries)
+
+          args = @filter ? ["-n", @filter] : []
+          system(bin, *args) ? 0 : ($?.exitstatus || 1)
+        end
+      end
+
+      private
+
+      def parse(args)
+        until args.empty?
+          arg = args.shift
+          case arg
+          when "-h", "--help"
+            puts USAGE
+            @exit = 0
+            return
+          when "-n", "--name"
+            if args.empty?
+              return usage_error("#{arg} requires a value")
+            end
+            @filter = args.shift
+          when "-I"
+            return usage_error("-I requires a value") if args.empty?
+
+            @includes << File.expand_path(args.shift, @root)
+          when /\A-I(.+)\z/ then @includes << File.expand_path($1, @root)
+          when /\A--name=(.*)\z/ then @filter = $1
+          when "--" then @paths.concat(args.shift(args.size))
+          when /\A-/ then return usage_error("unknown option: #{arg}")
+          else @paths << arg
+          end
+        end
+      end
+
+      def usage_error(message)
+        warn "spinel_test-unit: #{message}"
+        warn USAGE
+        @exit = 2
+      end
+
+      def test_files
+        paths = @paths.empty? ? ["test"] : @paths
+        paths.flat_map do |path|
+          full = File.expand_path(path, @root)
+          if File.directory?(full)
+            # fixtures/ below the given directory are skipped, unless the
+            # directory itself is inside fixtures/ (paths relative to @root,
+            # so where the project lives does not matter)
+            skip = !in_fixtures?(full)
+            (Dir.glob(File.join(full, "**", "*_test.rb")) + Dir.glob(File.join(full, "**", "test_*.rb")))
+              .reject { |f| skip && in_fixtures?(File.dirname(f)) }
+          elsif File.file?(full)
+            [full]
+          else
+            warn "spinel_test-unit: #{path}: no such file or directory"
+            []
+          end
+        end.uniq.sort
+      end
+
+      def build_entries(files)
+        sources = {}
+        (context_files + files).uniq.each { |f| sources[f] = File.read(f) }
+        add_required_files(sources)
+        result = Scanner.scan_files(sources, files)
+        result.warnings.each do |file, name, parent|
+          warn "spinel_test-unit: #{display(file)}: #{name} inherits from #{parent}, which is not defined in a scanned file; its tests are ignored"
+        end
+
+        by_file = result.classes.group_by(&:file)
+        order = []
+        files.each do |file|
+          next unless by_file[file]
+
+          by_file[file].each { |c| (c.files || [file]).each { |f| order << f } }
+        end
+        order.uniq.map do |file|
+          { file: file, require: require_name(file), classes: by_file[file] || [] }
+        end
+      end
+
+      # Follows string-literal require / require_relative transitively from the
+      # already collected files and adds the files found (e.g. a base test
+      # class provided by a library on an -I path) as scan-only context.
+      def add_required_files(sources)
+        gem_lib = File.expand_path("../..", __dir__) + File::SEPARATOR
+        dirs = [File.join(@root, "lib"), File.join(@root, "test"), @root] + @includes
+        dirs = dirs.select { |d| File.directory?(d) }.uniq
+        queue = sources.keys
+        until queue.empty?
+          file = queue.shift
+          Scanner.requires(sources[file]).each do |kind, name|
+            found = resolve_require(kind, name, file, dirs)
+            next if found.nil? || sources.key?(found) || found.start_with?(gem_lib)
+
+            begin
+              sources[found] = File.read(found)
+            rescue SystemCallError
+              next
+            end
+            queue << found
+          end
+        end
+      end
+
+      def resolve_require(kind, name, from, dirs)
+        name += ".rb" unless name.end_with?(".rb")
+        candidates = if kind == :relative || name.start_with?("./", "../")
+          [File.expand_path(name, File.dirname(from))]
+        elsif name.start_with?("/")
+          [name]
+        else
+          ([File.dirname(from)] + dirs).map { |d| File.expand_path(name, d) }
+        end
+        candidates.find { |c| File.file?(c) }
+      end
+
+      def context_files
+        dir = File.join(@root, "test")
+        Dir.glob(File.join(dir, "**", "*.rb")).reject { |f| in_fixtures?(File.dirname(f)) }.sort
+      end
+
+      # True if the directory path, relative to @root, has a fixtures component.
+      def in_fixtures?(dir)
+        rel = dir.start_with?(@root + File::SEPARATOR) ? dir.delete_prefix(@root + File::SEPARATOR) : dir
+        rel.split(File::SEPARATOR).include?("fixtures")
+      end
+
+      def display(file)
+        prefix = @root + File::SEPARATOR
+        file.start_with?(prefix) ? file.delete_prefix(prefix) : file
+      end
+
+      def require_name(file)
+        prefix = @root + File::SEPARATOR
+        if file.start_with?(prefix)
+          rel = file.delete_prefix(prefix)
+        else
+          # outside the root: use the name relative to the deepest -I dir
+          dir = @includes.select { |d| file.start_with?(d + File::SEPARATOR) }.max_by(&:size)
+          rel = dir ? file.delete_prefix(dir + File::SEPARATOR) : File.basename(file)
+        end
+        rel.delete_suffix(".rb")
+      end
+
+      def include_dirs(entries)
+        gem_lib = File.expand_path("../..", __dir__)
+        dirs = [File.join(@root, "lib"), File.join(@root, "test"), @root, gem_lib] + @includes
+        entries.each { |e| dirs << File.dirname(e[:file]) unless e[:file].start_with?(@root + File::SEPARATOR) }
+        dirs.select { |d| File.directory?(d) }.uniq
+      end
+
+      def compile(spinel, main, bin, entries)
+        cmd = [spinel] + include_dirs(entries).flat_map { |d| ["-I", d] } + [main, "-o", bin]
+        output, status = Open3.capture2e(*cmd)
+        unless status.success?
+          warn output unless output.empty?
+          warn "spinel_test-unit: compilation failed (#{cmd.join(" ")})"
+        end
+        status.success?
+      end
+    end
+  end
+end

data/lib/spinel_test/unit/generator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SpinelTest
+  module Unit
+    module Generator
+      # files: [{ require: "test/foo_test", classes: [TestClass, ...] }, ...]
+      def self.generate(files)
+        out = +"require \"spinel_test/unit\"\n"
+        files.each { |f| out << "require #{f[:require].dump}\n" }
+        out << ARGV_PARSER
+        out << "runner = SpinelTest::Unit::Runner.new(filter)\n"
+        files.each do |f|
+          f[:classes].each do |klass|
+            klass.methods.each do |m|
+              out << "t = #{klass.name}.new\n"
+              out << "runner.run(#{"#{klass.name}##{m}".dump}, t) { t.#{m} }\n"
+            end
+          end
+        end
+        out << "exit runner.finish\n"
+        out
+      end
+
+      ARGV_PARSER = <<~RUBY
+        filter = ""
+        i = 0
+        while i < ARGV.length
+          if ARGV[i] == "-n" && i + 1 < ARGV.length
+            filter = ARGV[i + 1]
+            i += 1
+          end
+          i += 1
+        end
+      RUBY
+    end
+  end
+end

data/lib/spinel_test/unit/runner.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module SpinelTest
+  module Unit
+    class Runner
+      def initialize(filter = "")
+        @filter = filter
+        @tests = 0
+        @assertions = 0
+        @failures = 0
+        @errors = 0
+        @details = []
+      end
+
+      def selected?(name)
+        @filter == "" || name.include?(@filter)
+      end
+
+      # Runs one test: setup, the block (which calls the test method), teardown.
+      def run(name, tc)
+        return unless selected?(name)
+
+        @tests += 1
+        status = 0
+        message = ""
+        begin
+          tc.setup
+          yield
+        rescue AssertionFailedError => e
+          status = 1
+          message = e.message
+        rescue Exception => e
+          raise e if fatal?(e)
+
+          status = 2
+          message = e.message
+        end
+        begin
+          tc.teardown
+        rescue Exception => e
+          raise e if fatal?(e)
+
+          if status == 0
+            status = 2
+            message = e.message
+          else
+            message = message + "\nTeardown also raised: " + e.message
+          end
+        end
+        @assertions += tc.assertions
+        if status == 0
+          print "."
+        elsif status == 1
+          print "F"
+          @failures += 1
+          @details.push("Failure: #{name}\n#{message}")
+        else
+          print "E"
+          @errors += 1
+          @details.push("Error: #{name}\n#{message}")
+        end
+      end
+
+      # Exceptions that must end the process instead of being reported as a test error.
+      def fatal?(e)
+        e.is_a?(SystemExit) || e.is_a?(Interrupt)
+      end
+
+      def passed?
+        @failures == 0 && @errors == 0
+      end
+
+      def summary
+        "#{@tests} tests, #{@assertions} assertions, #{@failures} failures, #{@errors} errors"
+      end
+
+      # Prints the report and returns the process exit status.
+      def finish
+        puts ""
+        @details.each do |d|
+          puts ""
+          puts d
+        end
+        puts ""
+        puts summary
+        if @tests == 0
+          puts "No tests were run#{@filter == "" ? "" : " (filter: " + @filter + ")"}"
+          return 1
+        end
+        passed? ? 0 : 1
+      end
+    end
+  end
+end

data/lib/spinel_test/unit/scanner.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module SpinelTest
+  module Unit
+    class Scanner
+      VISIBILITY = %i[private protected public].freeze
+      BASE_NAMES = ["SpinelTest::Unit::TestCase", "::SpinelTest::Unit::TestCase"].freeze
+
+      TestClass = Struct.new(:name, :methods, :file, :files, keyword_init: true)
+      # superclass is the raw name as written; scope is the lexical namespace it
+      # was written in. Both are qualified in resolve, once every class is known.
+      ClassInfo = Struct.new(:name, :superclass, :methods, :files, :hidden, :scope)
+      Result = Struct.new(:classes, :warnings, keyword_init: true)
+
+      def self.scan(sources)
+        new.scan(sources)
+      end
+
+      def self.scan_files(sources, targets)
+        new.scan_files(sources, targets)
+      end
+
+      # String-literal require / require_relative calls in source:
+      # [[:require | :relative, "name"], ...]. Unparseable source yields [].
+      def self.requires(source)
+        found = []
+        collect_requires(Prism.parse(source).value, found)
+        found
+      end
+
+      def self.collect_requires(node, found)
+        if node.is_a?(Prism::CallNode) && node.receiver.nil? &&
+           (node.name == :require || node.name == :require_relative)
+          arg = node.arguments&.arguments
+          if arg && arg.size == 1 && arg[0].is_a?(Prism::StringNode)
+            found << [node.name == :require ? :require : :relative, arg[0].unescaped]
+          end
+        end
+        node.compact_child_nodes.each { |child| collect_requires(child, found) }
+      end
+
+      def initialize
+        @classes = {}
+        @file = nil
+      end
+
+      def scan(sources)
+        Array(sources).each { |source| visit(Prism.parse(source).value, []) }
+        resolve
+      end
+
+      def scan_files(sources, targets)
+        sources.each do |path, source|
+          @file = path
+          visit(Prism.parse(source).value, [])
+        end
+        classes = resolve(targets).select { |c| targets.include?(c.file) }
+        Result.new(classes: classes, warnings: unresolved_warnings(targets))
+      end
+
+      private
+
+      def visit(node, namespace)
+        case node
+        when Prism::ModuleNode
+          visit(node.body, namespace + [path_name(node.constant_path)]) if node.body
+        when Prism::ClassNode
+          name = (namespace + [path_name(node.constant_path)]).join("::")
+          info = (@classes[name] ||= ClassInfo.new(name, nil, [], []))
+          info.files << @file if @file && !info.files.include?(@file)
+          if node.superclass
+            info.superclass = path_name(node.superclass)
+            info.scope = namespace
+          end
+          collect_methods(node.body, info)
+          visit(node.body, name.split("::")) if node.body
+        when Prism::ProgramNode
+          visit(node.statements, namespace)
+        when Prism::StatementsNode
+          node.body.each { |child| visit(child, namespace) }
+        end
+      end
+
+      def collect_methods(body, info)
+        return unless body.is_a?(Prism::StatementsNode)
+
+        hidden = false
+        body.body.each do |stmt|
+          if stmt.is_a?(Prism::CallNode) && stmt.receiver.nil? && VISIBILITY.include?(stmt.name)
+            if stmt.arguments.nil?
+              hidden = stmt.name != :public
+            elsif stmt.name != :public
+              # private def test_x / private :test_x
+              stmt.arguments.arguments.each do |arg|
+                name = arg.is_a?(Prism::DefNode) ? arg.name.to_s : (arg.is_a?(Prism::SymbolNode) ? arg.unescaped : nil)
+                info.methods.delete(name) if name
+                (info.hidden ||= []) << name if name
+              end
+            end
+            next
+          end
+          next if hidden
+          next unless stmt.is_a?(Prism::DefNode) && stmt.receiver.nil?
+
+          name = stmt.name.to_s
+          next if info.hidden&.include?(name)
+
+          info.methods << name if name.start_with?("test_") && !info.methods.include?(name)
+        end
+      end
+
+      def path_name(node)
+        return nil if node.nil?
+
+        case node
+        when Prism::ConstantReadNode then node.name.to_s
+        when Prism::ConstantPathNode
+          parent = node.parent ? path_name(node.parent) : ""
+          "#{parent}::#{node.name}"
+        end
+      end
+
+      # Qualified superclass name of info (nil if none), resolved against all
+      # scanned classes, so the result does not depend on definition order.
+      def superclass_of(info)
+        name = info.superclass
+        return nil if name.nil?
+        return name if BASE_NAMES.include?(name)
+        return name.delete_prefix("::") if name.start_with?("::")
+
+        scope = info.scope || []
+        scope.size.downto(0) do |n|
+          candidate = (scope.first(n) + [name]).join("::")
+          return candidate if @classes.key?(candidate)
+        end
+        name
+      end
+
+      def resolve(targets = nil)
+        @classes.values.filter_map do |info|
+          chain = ancestry(info)
+          next unless chain
+
+          methods = chain.reverse.flat_map(&:methods).uniq
+          next if methods.empty?
+
+          files = chain.reverse.flat_map(&:files).uniq
+          file = (targets && info.files.find { |f| targets.include?(f) }) || info.files.first
+          TestClass.new(name: info.name, methods: methods, file: file, files: files)
+        end
+      end
+
+      def unresolved_warnings(targets)
+        @classes.values.filter_map do |info|
+          next if info.methods.empty? || !info.files.any? { |f| targets.include?(f) }
+          next if ancestry(info)
+
+          parent = missing_parent(info)
+          [info.files.find { |f| targets.include?(f) }, info.name, parent] if parent
+        end
+      end
+
+      def missing_parent(info)
+        seen = {}
+        current = info
+        while current && !seen[current.name]
+          seen[current.name] = true
+          sup = superclass_of(current)
+          return nil if sup.nil? || BASE_NAMES.include?(sup)
+          return sup unless @classes[sup]
+
+          current = @classes[sup]
+        end
+        nil
+      end
+
+      def ancestry(info)
+        chain = []
+        current = info
+        seen = {}
+        while current
+          return nil if seen[current.name]
+
+          seen[current.name] = true
+          chain << current
+          sup = superclass_of(current)
+          return chain if BASE_NAMES.include?(sup)
+
+          current = sup && @classes[sup]
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/spinel_test/unit/test_case.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module SpinelTest
+  module Unit
+    class AssertionFailedError < StandardError
+    end
+
+    class TestCase
+      def initialize
+        @assertions = 0
+      end
+
+      def assertions
+        @assertions
+      end
+
+      def setup
+      end
+
+      def teardown
+      end
+
+      def assert(test, message = nil)
+        @assertions += 1
+        return true if test
+
+        raise AssertionFailedError, (message || "Failed assertion, no message given.")
+      end
+
+      def assert_equal(expected, actual, message = nil)
+        @assertions += 1
+        return true if expected == actual
+
+        msg = "Expected: #{expected.inspect}\n  Actual: #{actual.inspect}"
+        msg = message + "\n" + msg if message
+        raise AssertionFailedError, msg
+      end
+
+      def assert_nil(v, message = nil)
+        @assertions += 1
+        return true if v.nil?
+
+        msg = "Expected nil, got #{v.inspect}"
+        msg = message + "\n" + msg if message
+        raise AssertionFailedError, msg
+      end
+
+      def assert_includes(coll, item, message = nil)
+        @assertions += 1
+        return true if coll.include?(item)
+
+        msg = "#{coll.inspect} does not include #{item.inspect}"
+        msg = message + "\n" + msg if message
+        raise AssertionFailedError, msg
+      end
+
+      def assert_raise(klass)
+        @assertions += 1
+        begin
+          yield
+        rescue AssertionFailedError => e
+          # a failed assertion inside the block is not "the expected error"
+          raise e
+        rescue StandardError => e
+          return e if e.is_a?(klass)
+
+          raise AssertionFailedError, "Expected #{klass} but got #{e.class}"
+        end
+        raise AssertionFailedError, "Expected #{klass} but nothing was raised"
+      end
+    end
+  end
+end

data/lib/spinel_test/unit/toolchain.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SpinelTest
+  module Unit
+    # Finds the Spinel compiler.
+    #
+    #   1. SPINEL (a Spinel checkout, for example)
+    #   2. spinel on PATH
+    #   3. `mise which spinel` (mise is installed but not activated)
+    module Toolchain
+      def self.spinel
+        env = ENV["SPINEL"]
+        return env unless env.nil? || env.empty?
+
+        find_on_path("spinel") || mise_which("spinel")
+      end
+
+      def self.find_on_path(name)
+        ENV["PATH"].to_s.split(File::PATH_SEPARATOR).map { |d| File.join(d, name) }
+                   .find { |f| File.file?(f) && File.executable?(f) }
+      end
+
+      def self.mise_which(name)
+        return nil unless find_on_path("mise")
+
+        out = IO.popen(["mise", "which", name], err: File::NULL, &:read).strip
+        $?.success? && !out.empty? ? out : nil
+      end
+    end
+  end
+end

data/lib/spinel_test/unit/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module SpinelTest
+  module Unit
+    VERSION = "0.1.0"
+  end
+end

data/lib/spinel_test/unit.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "unit/version"
+require_relative "unit/test_case"
+require_relative "unit/runner"
+
+module SpinelTest; end

data/mise.toml

@@ -0,0 +1,14 @@
+# The tools for developing spinel_test-unit; `bin/setup` installs them.
+#
+# To use a Spinel checkout instead, point SPINEL at it in a
+# mise.local.toml (git-ignored); SPINEL wins over spinel on PATH:
+#
+#   [env]
+#   SPINEL = "{{ env.HOME }}/src/github.com/matz/spinel/spinel"
+
+[plugins]
+spinel = "https://github.com/y-yagi/mise-spinel"
+
+[tools]
+# A commit of matz/spinel (mise-spinel builds any git ref from source).
+spinel = { version = "b5204b507" }

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: spinel_test-unit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yuji Yaginuma
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+email:
+- yuuji.yaginuma@gmail.com
+executables:
+- spinel_test-unit
+extensions: []
+extra_rdoc_files: []
+files:
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/spinel_test-unit
+- lib/spinel_test/unit.rb
+- lib/spinel_test/unit/cli.rb
+- lib/spinel_test/unit/generator.rb
+- lib/spinel_test/unit/runner.rb
+- lib/spinel_test/unit/scanner.rb
+- lib/spinel_test/unit/test_case.rb
+- lib/spinel_test/unit/toolchain.rb
+- lib/spinel_test/unit/version.rb
+- mise.toml
+homepage: https://github.com/y-yagi/spinel_test-unit
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/y-yagi/spinel_test-unit
+  source_code_uri: https://github.com/y-yagi/spinel_test-unit
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.17
+specification_version: 4
+summary: An xUnit-style test framework for Spinel.
+test_files: []