minitest-strict 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ab7f3cff1adfd1e6a69afec2832299ca911bf2732cb3c205c9c116edfaf094eb
+  data.tar.gz: 8f45b484e5c08cd7c25498c028ff3f00540ef5b494561adbe964917fb2ebff87
+SHA512:
+  metadata.gz: 2e7508a3ff72d562ca069ea2fa8a5b9330ff6066121beb8f4162849673cac097dbb2cceba10b8a03884a90285f11924846763bd834c1b56029bf87240e76544e
+  data.tar.gz: bef6939ad19d6ecfea699367bbfd51f69e9a0fee664927f14ff254d0efe349e0403443c5c34804d290810fbe7974c687007958e547ae646c40bb590c038fa8bd

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2026-02-26
+
+### Added
+
+- `assert_true` / `refute_true` — assert a value is literally `true`, not just truthy
+- `assert_false` / `refute_false` — assert a value is literally `false`, not just falsey
+- `assert_eql` / `refute_eql` — assert equality using `eql?` instead of `==`
+- Strict `assert_predicate` / `refute_predicate` — require predicates to return `true` or `false`
+- Strict `assert_operator` / `refute_operator` — require operators to return `true` or `false`
+- Strict `assert_nil` / `refute_nil` — use `equal?` identity check instead of `nil?`

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Erik Berlin
+
+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,156 @@
+# `minitest-strict`
+
+[![Test](https://github.com/sferik/minitest-strict/actions/workflows/test.yml/badge.svg)](https://github.com/sferik/minitest-strict/actions/workflows/test.yml)
+[![Lint](https://github.com/sferik/minitest-strict/actions/workflows/lint.yml/badge.svg)](https://github.com/sferik/minitest-strict/actions/workflows/lint.yml)
+[![RDoc Coverage](https://github.com/sferik/minitest-strict/actions/workflows/rdoc_coverage.yml/badge.svg)](https://github.com/sferik/minitest-strict/actions/workflows/rdoc_coverage.yml)
+[![Mutant](https://github.com/sferik/minitest-strict/actions/workflows/mutant.yml/badge.svg)](https://github.com/sferik/minitest-strict/actions/workflows/mutant.yml)
+[![Steep](https://github.com/sferik/minitest-strict/actions/workflows/steep.yml/badge.svg)](https://github.com/sferik/minitest-strict/actions/workflows/steep.yml)
+[![Gem Version](https://badge.fury.io/rb/minitest-strict.svg)](https://badge.fury.io/rb/minitest-strict)
+
+#### Strict assertions for [Minitest](https://github.com/minitest/minitest).
+
+## Motivation
+
+Minitest's built-in assertions are lenient in ways that can mask bugs:
+
+- `assert`, `assert_predicate`, and `assert_operator` pass for any truthy return value, not just `true`. A predicate method that accidentally returns `1`, `"yes"`, or an object will silently pass.
+- `refute`, `refute_predicate`, and `refute_operator` pass for any falsey return value, not just `false`. A method that returns `nil` instead of `false` won't be caught.
+- `assert_nil` and `refute_nil` call `nil?`, which can be overridden on an object and mask bugs.
+- There's no built-in assertion that a value is exactly `true` or exactly `false`.
+- There's no built-in assertion for `eql?` equality (e.g. distinguishing `1` from `1.0`).
+
+`minitest-strict` fixes all of this. It redefines several Minitest assertions to require strict boolean return values and adds `assert_true`, `assert_false`, and `assert_eql` (with corresponding refutations).
+
+Strict assertions also make mutation testing with [Mutant](https://github.com/mbj/mutant) more effective. When assertions accept only exact boolean values, mutations like replacing `true` with `false` or swapping `nil` for `false` are reliably caught — mutations that lenient assertions would let survive.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "minitest-strict"
+```
+
+Then require it in your test helper:
+
+```ruby
+require "minitest/autorun"
+require "minitest/strict"
+```
+
+## New Assertions
+
+### `assert_true` / `refute_true`
+
+Passes only when the value is exactly `true` — not merely truthy.
+
+```ruby
+assert_true true      # pass
+assert_true 1         # fail
+assert_true "yes"     # fail
+assert_true nil       # fail
+
+refute_true false     # pass
+refute_true nil       # pass
+refute_true 1         # pass
+refute_true true      # fail
+```
+
+### `assert_false` / `refute_false`
+
+Passes only when the value is exactly `false` — not merely falsey.
+
+```ruby
+assert_false false    # pass
+assert_false nil      # fail
+assert_false 0        # fail
+assert_false ""       # fail
+
+refute_false true     # pass
+refute_false nil      # pass
+refute_false 0        # pass
+refute_false false    # fail
+```
+
+### `assert_eql` / `refute_eql`
+
+> [!NOTE]
+> `1 == 1.0` is `true` in Ruby, but `1.eql?(1.0)` is `false`. Be mindful of this distinction when comparing numeric values.
+
+Uses `eql?` instead of `==` for a stricter equality check. This distinguishes values that are `==` but not the same type.
+
+```ruby
+assert_eql 1, 1         # pass
+assert_eql "foo", "foo"  # pass
+assert_eql 1, 1.0       # fail — 1 == 1.0 is true, but 1.eql?(1.0) is false
+
+refute_eql 1, 1.0       # pass
+refute_eql 1, 2         # pass
+refute_eql 1, 1         # fail
+```
+
+## Strict Redefinitions
+
+> [!IMPORTANT]
+> The following Minitest assertions are **redefined** to require exact boolean return values. Existing tests may fail if the methods under test return truthy/falsey values instead of `true`/`false`.
+
+### `assert_predicate` / `refute_predicate`
+
+> [!WARNING]
+> Methods like `Numeric#nonzero?` return `self` or `nil` instead of `true` or `false`. These will fail with minitest-strict's `assert_predicate` and `refute_predicate`.
+
+Standard Minitest accepts any truthy/falsey return value. minitest-strict requires predicates to return exactly `true` or `false`.
+
+```ruby
+assert_predicate "", :empty?        # pass — String#empty? returns true
+assert_predicate "hello", :empty?   # fail — returns false
+
+# Catches methods that return truthy values other than true:
+assert_predicate 1, :nonzero?       # fail — returns 1, not true
+
+refute_predicate "hello", :empty?   # pass — returns false
+refute_predicate "", :empty?        # fail — returns true
+
+# Catches methods that return falsey values other than false:
+refute_predicate 0, :nonzero?       # fail — returns nil, not false
+```
+
+### `assert_operator` / `refute_operator`
+
+Requires operators to return exactly `true` or `false`.
+
+```ruby
+assert_operator 1, :<, 2           # pass — returns true
+assert_operator 2, :<, 1           # fail — returns false
+
+refute_operator 2, :<, 1           # pass — returns false
+refute_operator 1, :<, 2           # fail — returns true
+
+# Catches operators that return non-boolean values:
+obj.define_singleton_method(:<=>) { |_| 1 }
+assert_operator obj, :<=>, 2       # fail — returns 1, not true
+```
+
+### `assert_nil` / `refute_nil`
+
+> [!NOTE]
+> The standard Minitest implementation calls `nil?`, which can be overridden. minitest-strict uses `equal?` (identity) instead, so only the actual `nil` object passes.
+
+Uses `equal?` (identity) instead of `nil?`, so objects that override `nil?` can't fool the check.
+
+```ruby
+assert_nil nil                     # pass
+assert_nil false                   # fail
+
+# Can't be tricked by overriding nil?
+obj.define_singleton_method(:nil?) { true }
+assert_nil obj                     # fail — obj is not nil
+
+refute_nil 1                       # pass
+refute_nil false                   # pass
+refute_nil nil                     # fail
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).

data/lib/minitest/strict/version.rb

@@ -0,0 +1,8 @@
+module Minitest # :nodoc:
+  ##
+  # Version information for minitest-strict.
+  module Strict
+    # Current version of minitest-strict.
+    VERSION = "1.0.0".freeze
+  end
+end

data/lib/minitest/strict.rb

@@ -0,0 +1,141 @@
+require "minitest/assertions"
+require_relative "strict/version"
+
+##
+# Minitest extensions for strict boolean assertions.
+
+module Minitest
+  ##
+  # Strict assertion methods that require literal +true+ or +false+
+  # return values instead of truthy or falsey.
+  module Assertions
+    ##
+    # Fails unless +obj+ is literally +true+ (not just truthy).
+
+    def assert_true obj, msg = nil
+      msg = message(msg) { "Expected #{mu_pp obj} to be true" }
+      assert obj.equal?(true), msg
+    end
+
+    ##
+    # Fails unless +obj+ is literally +false+ (not just falsey).
+
+    def assert_false obj, msg = nil
+      msg = message(msg) { "Expected #{mu_pp obj} to be false" }
+      assert obj.equal?(false), msg
+    end
+
+    ##
+    # Fails if +obj+ is literally +true+.
+
+    def refute_true obj, msg = nil
+      msg = message(msg) { "Expected true to not be true" }
+      refute obj.equal?(true), msg
+    end
+
+    ##
+    # Fails if +obj+ is literally +false+.
+
+    def refute_false obj, msg = nil
+      msg = message(msg) { "Expected false to not be false" }
+      refute obj.equal?(false), msg
+    end
+
+    ##
+    # Fails unless +act+ is eql? to +exp+. Uses +Object#eql?+ for
+    # equality without type coercion. Eg:
+    #
+    #   assert_eql 1, 1     # pass
+    #   assert_eql 1, 1.0   # fail
+
+    def assert_eql exp, act, msg = nil
+      msg = message(msg) { "Expected #{mu_pp act} to be eql? to #{mu_pp exp}" }
+      assert exp.eql?(act), msg
+    end
+
+    ##
+    # Fails if +act+ is eql? to +exp+.
+
+    def refute_eql exp, act, msg = nil
+      msg = message(msg) { "Expected #{mu_pp act} to not be eql? to #{mu_pp exp}" }
+      refute exp.eql?(act), msg
+    end
+
+    # Strict redefinitions -- require boolean return values
+
+    silence = $VERBOSE
+    $VERBOSE = nil
+
+    ##
+    # Fails unless +o1+ is +op+. Requires +op+ to return literal
+    # +true+, not just a truthy value.
+    #
+    #   assert_predicate str, :empty?
+
+    def assert_predicate o1, op, msg = nil
+      assert_respond_to o1, op, include_all: true
+      msg = message(msg) { "Expected #{mu_pp o1} to be #{op}" }
+      assert_equal true, o1.__send__(op), msg
+    end
+
+    ##
+    # Fails if +o1+ is +op+. Requires +op+ to return literal
+    # +false+, not just a falsey value.
+    #
+    #   refute_predicate str, :empty?
+
+    def refute_predicate o1, op, msg = nil
+      assert_respond_to o1, op, include_all: true
+      msg = message(msg) { "Expected #{mu_pp o1} to not be #{op}" }
+      assert_equal false, o1.__send__(op), msg
+    end
+
+    ##
+    # For testing with binary operators. Requires the operator to
+    # return literal +true+, not just a truthy value. Falls through
+    # to assert_predicate if +o2+ is not given. Eg:
+    #
+    #   assert_operator 5, :<=, 4
+
+    def assert_operator o1, op, o2 = UNDEFINED, msg = nil
+      return assert_predicate o1, op, msg if o2 == UNDEFINED
+
+      assert_respond_to o1, op, include_all: true
+      msg = message(msg) { "Expected #{mu_pp o1} to be #{op} #{mu_pp o2}" }
+      assert_equal true, o1.__send__(op, o2), msg
+    end
+
+    ##
+    # For testing with binary operators. Requires the operator to
+    # return literal +false+, not just a falsey value. Falls through
+    # to refute_predicate if +o2+ is not given. Eg:
+    #
+    #   refute_operator 1, :>, 2
+
+    def refute_operator o1, op, o2 = UNDEFINED, msg = nil
+      return refute_predicate o1, op, msg if o2 == UNDEFINED
+
+      assert_respond_to o1, op, include_all: true
+      msg = message(msg) { "Expected #{mu_pp o1} to not be #{op} #{mu_pp o2}" }
+      assert_equal false, o1.__send__(op, o2), msg
+    end
+
+    ##
+    # Fails unless +obj+ is nil. Uses +equal?+ for identity check.
+
+    def assert_nil obj, msg = nil
+      msg = message(msg) { "Expected #{mu_pp obj} to be nil" }
+      assert obj.equal?(nil), msg
+    end
+
+    ##
+    # Fails if +obj+ is nil. Uses +equal?+ for identity check.
+
+    def refute_nil obj, msg = nil
+      msg = message(msg) { "Expected nil to not be nil" }
+      refute obj.equal?(nil), msg
+    end
+
+    $VERBOSE = silence
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: minitest-strict
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Erik Berlin
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.21'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.21'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+description: Redefines Minitest assertions to require strict boolean return values
+  and adds assert_true, assert_false, and assert_eql.
+email:
+- sferik@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/minitest/strict.rb
+- lib/minitest/strict/version.rb
+homepage: https://github.com/sferik/minitest-strict
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/sferik/minitest-strict
+  bug_tracker_uri: https://github.com/sferik/minitest-strict/issues
+  changelog_uri: https://github.com/sferik/minitest-strict/blob/main/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/minitest-strict
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Strict assertions for Minitest
+test_files: []