megatest 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffc34efd44ab621f7b9008e9f0a611715e8d3d66f6a524a407604166b6bb0612
-  data.tar.gz: a4149b89fe5d6fef8d0170f962bceefd860a75ccafe73f4f06a335fc27f3ffd2
+  metadata.gz: 10f2e6b7fd746d7e66164d84868f0314d06f403f649f5a985baaa8db9eb239c4
+  data.tar.gz: 9e6691bc050c0fd73647697e600f20c693d670c1f8982b779545e8d3140a9ef9
 SHA512:
-  metadata.gz: a1a160e73481e907da8678544c4a267dfec6cdee353ee46c79222224a6d69f474612bc95e819ecf6a092d2bca8e3e595c59162c366fb94fbb1056206d8af32ef
-  data.tar.gz: 3d9482774172c04968f9e85a5006a2ff8b38dc34e92b2b5d2a2a6dd04fa808c3daa1381d97cea2cfb263f19adb6a3d7dfe0b51c54cf7612d588cbead1582c456
+  metadata.gz: e03b691bdf5d28c09575c4c3c2d0995e067f3a7e88159f640d5d1dc0c92010470ec36c20bfb52c3cbf63b4edaf3d09afd24cc5799a5d8c9bf1a5dbd206ae3b86
+  data.tar.gz: b742c4c6d8656cf04ba801112bcf913e1224eef13f8256b5ef7c950deaf9c1a24958c7c294f76c477b01a1017adbf849358e5ff0dcea7761dc8b1c18468288f6

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [Unreleased]
 
+## [0.6.0] - 2025-01-17
+
+- Allow defining setup and teardown with method names.
+- Allow multiple `setup`, `around` and `teardown` blocks in the same test suite.
+
+## [0.5.0] - 2025-01-17
+
+- Adds `megatest/autorun`
+- Adds `assert_nothing_raised`.
+- Adds `assert_difference`.
+- Adds `assert_changes`.
+- Adds `assert_not_*` aliases.
+- Adds `match:` argument to `assert_raises`.
+
 ## [0.4.0] - 2025-11-12
 
 - Allow configuring the test glob via `config.test_globs`.

data/lib/megatest/assertions.rb

@@ -67,6 +67,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not, :refute
 
     def assert_nil(actual, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -85,6 +86,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_nil, :refute_nil
 
     def assert_equal(expected, actual, msg = nil, message: nil, allow_nil: false)
       message = @__m.msg(msg, message)
@@ -116,6 +118,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_equal, :refute_equal
 
     def assert_includes(collection, object, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -134,6 +137,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_includes, :refute_includes
 
     def assert_empty(object, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -152,6 +156,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_empty, :refute_empty
 
     def assert_instance_of(klass, actual, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -170,6 +175,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_instance_of, :refute_instance_of
 
     def assert_kind_of(klass, actual, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -188,6 +194,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_kind_of, :refute_kind_of
 
     def assert_predicate(actual, predicate, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -206,6 +213,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_predicate, :refute_predicate
 
     def assert_match(original_matcher, obj, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -238,6 +246,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_no_match, :refute_match
 
     def assert_respond_to(object, method, msg = nil, message: nil, include_all: false)
       message = @__m.msg(msg, message)
@@ -256,6 +265,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_respond_to, :refute_respond_to
 
     def assert_same(expected, actual, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -294,21 +304,36 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_same, :refute_same
 
-    def assert_raises(expected = StandardError, *expected_exceptions, message: nil)
+    def assert_raises(expected = StandardError, *expected_exceptions, match: nil, message: nil)
       msg = expected_exceptions.pop if expected_exceptions.last.is_a?(String)
       message = @__m.msg(msg, message)
+
+      matcher = if match
+        if ::String === match
+          ::Regexp.new(::Regexp.escape(match))
+        else
+          match
+        end
+      end
+
       @__m.assert do
         @__m.fail("assert_raises requires a block to capture errors.") unless block_given?
 
         begin
+          before_yield = __LINE__
           yield
         rescue expected, *expected_exceptions => exception
+          if matcher && !matcher.match?(exception.message)
+            @__m.fail(message, "Expected", @__m.pp(match), "to match", @__m.pp(exception.message))
+          end
+
           return exception
         rescue ::Megatest::Assertion, *::Megatest::IGNORED_ERRORS
           raise # Pass through
         rescue ::Exception => unexepected_exception
-          error = @__m.strip_backtrace(unexepected_exception, __FILE__, __LINE__ - 6, 0)
+          error = @__m.strip_backtrace(unexepected_exception, __FILE__, before_yield + 1, 0)
 
           expected_pp = if expected_exceptions.empty?
             @__m.pp(expected)
@@ -317,15 +342,26 @@ module Megatest
           end
 
           @__m.fail(message, "#{expected_pp} exception expected, not:\n#{@__m.pp(error)}")
-        end
-
-        expected_pp = if expected_exceptions.empty?
-          @__m.pp(expected)
         else
-          expected_exceptions.map { |e| @__m.pp(e) }.join(", ") << " or #{@__m.pp(expected)}"
+          expected_pp = if expected_exceptions.empty?
+            @__m.pp(expected)
+          else
+            expected_exceptions.map { |e| @__m.pp(e) }.join(", ") << " or #{@__m.pp(expected)}"
+          end
+
+          @__m.fail(message, "Expected", expected_pp, "but nothing was raised.")
         end
+      end
+    end
+    alias :assert_raise :assert_raises
 
-        @__m.fail(message, "Expected", expected_pp, "but nothing was raised.")
+    def assert_nothing_raised
+      @__m.assert do
+        yield
+      rescue ::Megatest::Assertion, *::Megatest::IGNORED_ERRORS
+        raise # Pass through
+      rescue Exception => unexepected_exception
+        raise ::Megatest::UnexpectedError, unexepected_exception
       end
     end
 
@@ -367,6 +403,114 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_operator, :refute_operator
+
+    def assert_difference(expression, difference = @__m.unset, message: nil, &block)
+      expressions = if @__m.set?(difference)
+        Array(expression).to_h { |e| [e, difference] }
+      elsif Hash === expression
+        expression
+      else
+        Array(expression).to_h { |e| [e, 1] }
+      end
+
+      exps = expressions.keys.map { |e| @__m.expression(e, block) }
+
+      @__m.assert do
+        before = exps.map(&:call)
+
+        retval = @__m.safe_yield(&block)
+
+        expressions.zip(exps, before) do |(code, diff), exp, before_value|
+          actual = exp.call
+          expected = before_value + diff
+          unless expected == actual
+            error = "`#{@__m.pp_expression(code)}` didn't change by #{diff}, but by #{actual - before_value}."
+            @__m.fail(message, error)
+          end
+        end
+
+        retval
+      end
+    end
+
+    def refute_difference(expressions, message: nil, &block)
+      exps = Array(expressions).map { |e| @__m.expression(e, block) }
+
+      @__m.assert do
+        before = exps.map(&:call)
+
+        retval = @__m.safe_yield(&block)
+
+        exps.zip(before) do |exp, before_value|
+          actual = exp.call
+          unless before_value == actual
+            error = "Expected `#{@__m.pp_expression(exp)}` to not change, but it changed from #{@__m.pp(before_value)} to #{@__m.pp(actual)}."
+            @__m.fail(message, error)
+          end
+        end
+
+        retval
+      end
+    end
+    alias_method :assert_no_difference, :refute_difference
+
+    def assert_changes(expression, msg = nil, message: nil, from: @__m.unset, to: @__m.unset, &block)
+      message = @__m.msg(msg, message)
+      exp = @__m.expression(expression, block)
+      @__m.assert do
+        before = exp.call
+        if @__m.set?(from) && !(from === before)
+          @__m.fail(message, "Expected `#{@__m.pp_expression(exp)}` to starts from #{@__m.pp(from)}, but was #{@__m.pp(before)}")
+        end
+
+        retval = assert_nothing_raised(&block)
+
+        after = exp.call
+
+        if before == after
+          details = "Expected `#{@__m.pp_expression(exp)}` to change"
+          if @__m.set?(to)
+            details = "#{details} to #{@__m.pp(to)}"
+          end
+
+          if before == to
+            details = "#{details}, but it was already #{@__m.pp(to)}."
+          else
+            details = "#{details}, but it stayed #{@__m.pp(before)}"
+          end
+
+          @__m.fail(message, details)
+        end
+
+        if @__m.set?(to) && !(to === after)
+          @__m.fail(message, "Expected `#{@__m.pp_expression(exp)}` to change to #{@__m.pp(to)}, got #{@__m.pp(after)}")
+        end
+
+        retval
+      end
+    end
+
+    def refute_changes(expression, msg = nil, message: nil, from: @__m.unset, &block)
+      message = @__m.msg(msg, message)
+      exp = @__m.expression(expression, block)
+      @__m.assert do
+        before = exp.call
+        if @__m.set?(from) && !(from === before)
+          @__m.fail(message, "Expected `#{@__m.pp_expression(exp)}` to start from #{@__m.pp(from)}, but was #{@__m.pp(before)}.")
+        end
+
+        retval = assert_nothing_raised(&block)
+
+        after = exp.call
+        unless before == after
+          @__m.fail(message, "Expected `#{@__m.pp_expression(exp)}` to not change, but it changed from #{@__m.pp(before)} to #{@__m.pp(after)}.")
+        end
+
+        retval
+      end
+    end
+    alias_method :assert_no_changes, :refute_changes
 
     def assert_in_delta(expected, actual, delta = 0.001, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -387,6 +531,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_in_delta, :refute_in_delta
 
     def assert_in_epsilon(expected, actual, epsilon = 0.001, msg = nil, message: nil)
       message = @__m.msg(msg, message)
@@ -409,6 +554,7 @@ module Megatest
         end
       end
     end
+    alias_method :assert_not_epsilon, :refute_in_epsilon
 
     def skip(message = nil)
       message ||= "Skipped, no message given"

data/lib/megatest/autorun.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "megatest"
+
+unless Megatest.running
+  root = File.expand_path("../../", __dir__)
+  rubyopt = "#{ENV.fetch("RUBYOPT", nil)} -I#{root}/lib"
+  exec({ "RUBYOPT" => rubyopt }, "#{root}/exe/megatest", $PROGRAM_NAME, *ARGV)
+end

data/lib/megatest/cli.rb

@@ -10,7 +10,7 @@ module Megatest
 
     class << self
       def run!
-        program_name = $PROGRAM_NAME
+        program_name = ENV.fetch("MEGATEST_PROGRAM_NAME", $PROGRAM_NAME)
         if paths = ENV["PATH"]
           paths.split(":").each do |path|
             if program_name.start_with?(path)
@@ -69,6 +69,8 @@ module Megatest
     end
 
     def configure
+      Megatest.running = true
+
       if @runner = RUNNERS[@argv.first]
         @argv.shift
       end

data/lib/megatest/compat.rb

@@ -4,18 +4,6 @@
 
 module Megatest
   module Compat
-    unless Enumerable.method_defined?(:filter_map) # RUBY_VERSION >= "2.7"
-      module FilterMap
-        refine Enumerable do
-          def filter_map(&block)
-            result = map(&block)
-            result.compact!
-            result
-          end
-        end
-      end
-    end
-
     unless Symbol.method_defined?(:start_with?) # RUBY_VERSION >= "2.7"
       module StartWith
         refine Symbol do

data/lib/megatest/dsl.rb

@@ -136,8 +136,14 @@ module Megatest
     end
 
     # Registers a block to be invoked before every test cases.
-    def setup(&block)
-      ::Megatest.registry.suite(self).on_setup(block)
+    def setup(*methods, &block)
+      suite = ::Megatest.registry.suite(self)
+      methods.each do |m|
+        suite.on_setup(-> { send(m) })
+      end
+      if block
+        suite.on_setup(block)
+      end
     end
 
     # Registers a block to be invoked around every test cases.
@@ -157,8 +163,14 @@ module Megatest
 
     # Registers a block to be invoked after every test cases,
     # regardless of whether it passed or failed.
-    def teardown(&block)
-      ::Megatest.registry.suite(self).on_teardown(block)
+    def teardown(*methods, &block)
+      suite = ::Megatest.registry.suite(self)
+      methods.each do |m|
+        suite.on_teardown(-> { send(m) })
+      end
+      if block
+        suite.on_teardown(block)
+      end
     end
   end
 end

data/lib/megatest/runtime.rb

@@ -139,6 +139,49 @@ module Megatest
       end
     end
 
+    def safe_yield
+      yield
+    rescue Assertion, *IGNORED_ERRORS
+      raise
+    rescue ::Exception => unexepected_exception
+      raise UnexpectedError, unexepected_exception
+    end
+
+    UNSET = BasicObject.new
+
+    def unset
+      UNSET
+    end
+
+    def unset?(arg)
+      UNSET.equal?(arg)
+    end
+
+    def set?(arg)
+      !UNSET.equal?(arg)
+    end
+
+    class Expression
+      attr_reader :string
+
+      def initialize(string, block)
+        @string = string
+        @block = block
+      end
+
+      def call
+        eval(@string, @block.binding)
+      end
+    end
+
+    def expression(expression, block)
+      if String === expression
+        Expression.new(expression, block)
+      else
+        expression
+      end
+    end
+
     def minitest_compatibility?
       @config.minitest_compatibility
     end
@@ -147,6 +190,53 @@ module Megatest
       @config.render_object(object)
     end
 
+    def pp_expression(callable)
+      case callable
+      when Expression
+        callable.string
+      when Proc
+        # Logic borrowed from Active Support.
+        if defined?(RubyVM::InstructionSequence)
+          iseq = RubyVM::InstructionSequence.of(callable)
+          return pp(callable) unless iseq
+
+          source = if RubyVM::InstructionSequence.method_defined?(:script_lines) && iseq.script_lines
+            iseq.script_lines.join("\n")
+          elsif File.readable?(iseq.absolute_path)
+            File.read(iseq.absolute_path)
+          end
+          return pp(callable) unless source
+
+          location = iseq.to_a[4][:code_location]
+          return pp(callable) unless location
+
+          lines = source.lines[(location[0] - 1)..(location[2] - 1)]
+          lines[-1] = lines[-1].byteslice(0...location[3])
+          lines[0] = lines[0].byteslice(location[1]...-1)
+          source = lines.join.strip
+
+          # Ruby 4.1.0dev includes the `->`
+          source.delete_prefix!("->")
+          source.strip!
+
+          # We ignore procs defined with do/end as they are likely multi-line anyway.
+          if source.start_with?("{")
+            source.delete_suffix!("}")
+            source.delete_prefix!("{")
+            source.strip!
+            # It won't read nice if the callable contains multiple
+            # lines, and it should be a rare occurrence anyway.
+            # Same if it takes arguments.
+            if !source.include?("\n") && !source.start_with?("|")
+              return source
+            end
+          end
+        end
+      end
+
+      pp(callable)
+    end
+
     def diff(expected, actual)
       @config.diff(expected, actual)
     end

data/lib/megatest/selector.rb

@@ -57,13 +57,12 @@ module Megatest
       attr_reader :path
 
       def initialize(config, path, filter = nil)
+        @config = config
         @path = File.expand_path(path)
         if @directory = File.directory?(@path)
           @path = File.join(@path, "/")
-          @paths = Megatest.glob(config.test_globs.map { |pattern| File.join(@path, pattern) })
-        else
-          @paths = [@path]
         end
+        @paths = nil
         @filter = filter
       end
 
@@ -81,7 +80,7 @@ module Megatest
       end
 
       def append_paths(paths_to_load)
-        paths_to_load.concat(@paths)
+        paths_to_load.concat(paths)
       end
 
       def select(registry)
@@ -99,6 +98,16 @@ module Megatest
           test_cases
         end
       end
+
+      private
+
+      def paths
+        @paths ||= if @directory
+          Megatest.glob(@config.test_globs.map { |pattern| File.join(@path, pattern) })
+        else
+          [@path]
+        end
+      end
     end
 
     class NegativeLoader

data/lib/megatest/state.rb

@@ -28,14 +28,14 @@ module Megatest
     using Compat::StartWith unless Symbol.method_defined?(:start_with?)
 
     class Suite
-      attr_reader :setup_callback, :teardown_callback, :around_callback
+      attr_reader :setup_callbacks, :teardown_callbacks, :around_callbacks
 
       def initialize(registry)
         @registry = registry
         @tags = nil
-        @setup_callback = nil
-        @teardown_callback = nil
-        @around_callback = nil
+        @setup_callbacks = []
+        @teardown_callbacks = []
+        @around_callbacks = []
         @current_context = nil
         @current_tags = nil
       end
@@ -87,24 +87,21 @@ module Megatest
       end
 
       def on_setup(block)
-        raise Error, "The setup block is already defined" if @setup_callback
         raise Error, "setup blocks can't be defined in context blocks" if @current_context
 
-        @setup_callback = block
+        @setup_callbacks.unshift(block)
       end
 
       def on_around(block)
-        raise Error, "The around block is already defined" if @around_callback
         raise Error, "around blocks can't be defined in context blocks" if @current_context
 
-        @around_callback = block
+        @around_callbacks << block
       end
 
       def on_teardown(block)
-        raise Error, "The teardown block is already defined" if @teardown_callback
         raise Error, "teardown blocks can't be defined in context blocks" if @current_context
 
-        @teardown_callback = block
+        @teardown_callbacks << block
       end
     end
 
@@ -368,21 +365,19 @@ module Megatest
         cmp || 0
       end
 
-      def each_setup_callback
+      def each_setup_callback(&block)
         @test_suite.ancestors.reverse_each do |test_suite|
-          yield test_suite.setup_callback if test_suite.setup_callback
+          test_suite.setup_callbacks.each(&block)
         end
       end
 
-      using Compat::FilterMap unless Enumerable.method_defined?(:filter_map)
-
       def around_callbacks
-        @test_suite.ancestors.filter_map(&:around_callback)
+        @test_suite.ancestors.flat_map(&:around_callbacks)
       end
 
-      def each_teardown_callback
+      def each_teardown_callback(&block)
         @test_suite.ancestors.each do |test_suite|
-          yield test_suite.teardown_callback if test_suite.teardown_callback
+          test_suite.teardown_callbacks.each(&block)
         end
       end
 

data/lib/megatest/version.rb

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

data/lib/megatest.rb

@@ -14,7 +14,11 @@ module Megatest
   IGNORED_ERRORS = [NoMemoryError, SignalException, SystemExit].freeze
   DEFAULT_TEST_GLOB = "**/{test_*,*_test}.rb"
 
+  @running = false
+
   class << self
+    attr_accessor :running
+
     def fork?
       Process.respond_to?(:fork) && !ENV["NO_FORK"]
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: megatest
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Jean Boussier
@@ -25,6 +25,7 @@ files:
 - exe/megatest
 - lib/megatest.rb
 - lib/megatest/assertions.rb
+- lib/megatest/autorun.rb
 - lib/megatest/backtrace.rb
 - lib/megatest/cli.rb
 - lib/megatest/compat.rb
@@ -74,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Modern test-unit style test framework
 test_files: []