megatest 0.1.0

data/lib/megatest/subprocess.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Megatest
+  class Subprocess
+    class << self
+      def spawn(read, write, action)
+        Process.spawn(
+          RbConfig.ruby,
+          File.expand_path("../subprocess/main.rb", __FILE__),
+          read.fileno.to_s,
+          write.fileno.to_s,
+          action,
+          read.fileno => read,
+          write.fileno => write,
+        )
+      end
+    end
+
+    def initialize(read, write)
+      @read = read
+      @write = write
+    end
+
+    def run(action)
+      case action
+      when "run_test"
+        config = Marshal.load(@read)
+        Megatest.init(config)
+
+        test_path = Marshal.load(@read)
+        test_cases = Megatest.load_tests(config, [test_path])
+        test_id = Marshal.load(@read)
+        @read.close
+        test_case = test_cases.find { |t| t.id == test_id }
+        unless test_case
+          exit!(1) # TODO: error
+        end
+
+        result = Runner.new(config).run(test_case)
+        Marshal.dump(result, @write)
+        @write.close
+      else
+        exit!(1)
+      end
+      exit!(0)
+    end
+  end
+end

data/lib/megatest/test.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "megatest/assertions"
+
+module Megatest
+  ##
+  # Subclass Test to define a test suite
+  #
+  # See Megatest::Assertions and Megatest::DSL
+  class Test
+    # :stopdoc:
+    # Megatest::Test is meant to be subclassed by users, as such it's written in an
+    # adversarial way, we expose as little methods, instance variable and constants
+    # as possible, and always reference our own constants with their fully qualified name.
+
+    class << self
+      if respond_to?(:const_source_location)
+        def inherited(subclass)
+          super
+          const_source_location = if subclass.name
+            ::Object.const_source_location(subclass.name)
+          else
+            location = caller_locations.find { |l| l.base_label != "inherited" && !l.path.start_with?("<internal:") }
+            [location.path, location.lineno]
+          end
+          ::Megatest.registry.register_suite(subclass, const_source_location)
+        end
+      else
+        def inherited(subclass)
+          super
+          location = caller_locations.find { |l| l.base_label != "inherited" && !l.path.start_with?("<internal:") }
+          const_source_location = [location.path, location.lineno]
+          ::Megatest.registry.register_suite(subclass, const_source_location)
+        end
+      end
+
+      if Thread.respond_to?(:each_caller_location)
+        def include(*modules)
+          super
+
+          location = Thread.each_caller_location do |l|
+            break l if l.base_label != "include" && !l.path.start_with?("<internal:")
+          end
+          include_location = [location.path, location.lineno]
+
+          modules.each do |mod|
+            if mod.is_a?(::Megatest::DSL) || mod.instance_methods.any? { |m| m.start_with?("test_") }
+              ::Megatest.registry.shared_suite(mod).included_by(self, include_location)
+            end
+          end
+        end
+      else
+        using Compat::StartWith unless Symbol.method_defined?(:start_with?)
+
+        def include(*modules)
+          super
+
+          location = caller_locations.find do |l|
+            l if l.base_label != "include"
+          end
+          include_location = [location.path, location.lineno]
+
+          modules.each do |mod|
+            if mod.is_a?(::Megatest::DSL) || mod.instance_methods.any? { |m| m.start_with?("test_") }
+              ::Megatest.registry.shared_suite(mod).included_by(self, include_location)
+            end
+          end
+        end
+      end
+    end
+
+    def initialize(runtime)
+      @__m = runtime
+    end
+
+    def before_setup
+    end
+
+    # For Minitest compatibility
+    def name
+      @__m.test_case.name
+    end
+
+    def setup
+    end
+
+    def after_setup
+    end
+
+    def before_teardown
+    end
+
+    def teardown
+    end
+
+    def after_teardown
+    end
+
+    # :startdoc:
+    extend DSL
+    include Assertions
+
+    # Returns the current Megatest::State::TestCase instance
+    # Can be used for self introspection
+    def __test__
+      @__m.test_case
+    end
+
+    # Returns the current Megatest::TestCaseResult instance
+    # Can be used for self introspection during teardown
+    def __result__
+      @__m.result
+    end
+  end
+end

data/lib/megatest/test_task.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+begin
+  require "rake/tasklib"
+rescue LoadError => e
+  warn e.message
+  return
+end
+
+module Megatest # :nodoc:
+  ##
+  # Megatest::TestTask is a rake helper that generates several rake
+  # tasks under the main test task's name-space.
+  #
+  #   task <name>      :: the main test task
+  #   task <name>:cmd  :: prints the command to use
+  #
+  # Examples:
+  #
+  #   Megatest::TestTask.create
+  #
+  # The most basic and default setup.
+  #
+  #   Megatest::TestTask.create :my_tests
+  #
+  # The most basic/default setup, but with a custom name
+  #
+  #   Megatest::TestTask.create :unit do |t|
+  #     t.warning = true
+  #   end
+  #
+  # Customize the name and only run unit tests.
+
+  class TestTask < Rake::TaskLib
+    WINDOWS = RbConfig::CONFIG["host_os"] =~ /mswin|mingw/ # :nodoc:
+
+    ##
+    # Create several test-oriented tasks under +name+. Takes an
+    # optional block to customize variables.
+
+    def self.create(name = :test, &block)
+      task = new name
+      task.instance_eval(&block) if block
+      task.define
+      task
+    end
+
+    ##
+    # Extra arguments to pass to the tests. Defaults empty.
+
+    attr_accessor :extra_args
+
+    ##
+    # Extra library directories to include.
+
+    attr_accessor :libs
+
+    ##
+    # The name of the task and base name for the other tasks generated.
+
+    attr_accessor :name
+
+    ##
+    # Test files or directories to run. Defaults to +test/+
+
+    attr_accessor :tests
+
+    ##
+    # Turn on ruby warnings (-w flag). Defaults to true.
+
+    attr_accessor :warning
+
+    ##
+    # Print out commands as they run. Defaults to Rake's +trace+ (-t
+    # flag) option.
+
+    attr_accessor :verbose
+
+    ##
+    # Show full backtraces on error
+
+    attr_accessor :full_backtrace
+
+    # Task prerequisites.
+    attr_accessor :deps
+
+    attr_accessor :command
+
+    ##
+    # Use TestTask.create instead.
+
+    def initialize(name = :test) # :nodoc:
+      super()
+      @libs = []
+      @name = name
+      @tests = ["test/"]
+      @extra_args = []
+      @verbose = Rake.application.options.trace || Rake.verbose == true
+      @warning = true
+      @deps = []
+      if @name.is_a?(Hash)
+        @deps = @name.values.first
+        @name = @name.keys.first
+      end
+    end
+
+    def define # :nodoc:
+      desc "Run the test suite. Use N, X, A, and TESTOPTS to add flags/args."
+      task name => Array(deps) do
+        sh(*make_test_cmd, verbose: verbose)
+      end
+
+      desc "Print out the test command. Good for profiling and other tools."
+      task "#{name}:cmd" do
+        puts make_test_cmd.join(" ")
+      end
+    end
+
+    ##
+    # Generate the test command-line.
+
+    def make_test_cmd
+      cmd = [command || "megatest"]
+      cmd << "-I#{libs.join(File::PATH_SEPARATOR)}" unless libs.empty?
+      # cmd << "-w" if warning
+      cmd << "--backtrace" if full_backtrace
+      cmd.concat(extra_args)
+      cmd.concat(tests)
+      cmd
+    end
+  end
+end

data/lib/megatest/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Megatest
+  VERSION = "0.1.0"
+end

data/lib/megatest.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative "megatest/version"
+
+module Megatest
+  Error = Class.new(StandardError)
+  AlreadyDefinedError = Class.new(Error)
+  LoadError = Class.new(Error)
+
+  # :stopdoc:
+
+  ROOT = -File.expand_path("../", __FILE__)
+  PWD = File.join(Dir.pwd, "/")
+  IGNORED_ERRORS = [NoMemoryError, SignalException, SystemExit].freeze
+
+  class << self
+    def fork?
+      Process.respond_to?(:fork) && !ENV["NO_FORK"]
+    end
+
+    def now
+      Process.clock_gettime(Process::CLOCK_REALTIME)
+    end
+
+    def relative_path(absolute_path)
+      absolute_path&.delete_prefix(PWD)
+    end
+
+    def append_load_path(config)
+      config.load_paths.each do |path|
+        abs_path = File.absolute_path(path)
+        $LOAD_PATH.unshift(abs_path) unless $LOAD_PATH.include?(abs_path)
+      end
+    end
+
+    def init(config)
+      if config.deprecations && ::Warning.respond_to?(:[]=)
+        ::Warning[:deprecated] = true
+      end
+
+      # We initiale the seed in case there is some Random use
+      # at code loading time.
+      Random.srand(config.seed)
+    end
+
+    def load_tests(config, paths = nil)
+      registry = with_registry do
+        append_load_path(config)
+        load_test_helper(config.selectors.main_paths)
+
+        paths ||= config.selectors.paths(random: config.random)
+        paths.each do |path|
+          Kernel.require(path)
+        rescue LoadError
+          raise InvalidArgument, "Failed to load #{relative_path(path)}"
+        end
+      end
+
+      config.selectors.select(registry, random: config.random)
+    end
+
+    def load_config(config)
+      load_files(config.selectors.main_paths, "test_config.rb")
+    end
+
+    def load_test_helper(paths)
+      load_files(paths, "test_helper.rb")
+    end
+
+    def load_files(paths, name)
+      scaned = {}
+      paths.each do |path|
+        path = File.dirname(path) unless File.directory?(path)
+
+        while path.start_with?(PWD)
+          break if scaned[path]
+
+          scaned[path] = true
+
+          config_path = File.join(path, name)
+          if File.exist?(config_path)
+            require(config_path)
+            break
+          end
+
+          path = File.dirname(path)
+        end
+      end
+      nil
+    end
+
+    if Dir.method(:glob).parameters.include?(%i(key sort)) # Ruby 2.7+
+      def glob(path)
+        Dir.glob(File.join(path, "**/{test_*,*_test}.rb"))
+      end
+    else
+      def glob(path)
+        paths = Dir.glob(File.join(path, "**/{test_*,*_test}.rb"))
+        paths.sort!
+        paths
+      end
+    end
+  end
+end
+
+require "megatest/compat"
+require "megatest/patience_diff"
+require "megatest/differ"
+require "megatest/pretty_print"
+require "megatest/output"
+require "megatest/backtrace"
+require "megatest/config"
+require "megatest/selector"
+require "megatest/runner"
+require "megatest/runtime"
+require "megatest/state"
+require "megatest/reporters"
+require "megatest/queue"
+require "megatest/queue_reporter"
+require "megatest/executor"
+require "megatest/subprocess"
+require "megatest/dsl"
+require "megatest/test"

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: megatest
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jean Boussier
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-08-20 00:00:00.000000000 Z
+dependencies: []
+description: Largely API compatible with test-unit / minitest, but with lots of extra
+  modern niceties like a proper CLI, test distribution, etc.
+email:
+- jean.boussier@gmail.com
+executables:
+- megatest
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- TODO.md
+- exe/megatest
+- lib/megatest.rb
+- lib/megatest/assertions.rb
+- lib/megatest/backtrace.rb
+- lib/megatest/cli.rb
+- lib/megatest/compat.rb
+- lib/megatest/config.rb
+- lib/megatest/differ.rb
+- lib/megatest/dsl.rb
+- lib/megatest/executor.rb
+- lib/megatest/multi_process.rb
+- lib/megatest/output.rb
+- lib/megatest/patience_diff.rb
+- lib/megatest/pretty_print.rb
+- lib/megatest/queue.rb
+- lib/megatest/queue_monitor.rb
+- lib/megatest/queue_reporter.rb
+- lib/megatest/redis_queue.rb
+- lib/megatest/reporters.rb
+- lib/megatest/runner.rb
+- lib/megatest/runtime.rb
+- lib/megatest/selector.rb
+- lib/megatest/state.rb
+- lib/megatest/subprocess.rb
+- lib/megatest/subprocess/main.rb
+- lib/megatest/test.rb
+- lib/megatest/test_task.rb
+- lib/megatest/version.rb
+homepage: https://github.com/byroot/megatest
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org/
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/byroot/megatest
+  source_code_uri: https://github.com/byroot/megatest
+  changelog_uri: https://github.com/byroot/megatest/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: Modern test-unit style test framework
+test_files: []