soft-assert 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d8b100ae72eaf55529aeb0c85f5e841ab20b4e16bccfabc3ddec439a08a330f5
+  data.tar.gz: ee7cbf7bde40e163b3db7b518f7f6c7148dcf9973f2c3d2453bf0c63b65d4644
+SHA512:
+  metadata.gz: 59668bf4be1d6daf2d7936f7289e55afc8b4d4a92e37d815c1e1a466a576a09a7f53d44944936611a829c065d2a669759d499e068d0e5baaa80cd2f2b9199d01
+  data.tar.gz: 6fea768c1ae7b387f90a23557be88c22f966b084a88f9f2847dafb0012f89727028ddde2277a079e62411076975cb4007b4497f16416ca75b5b130c868adbca2

data/lib/soft_assert.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require 'minitest/assertions'
+require 'test/unit/assertions'
+
+# SoftAssert is a module that provides a set of assertion methods that can be used in tests.
+# These methods allow you to check that your code is behaving as expected.
+# Unlike hard assertions, soft assertions do not stop the execution of the test when they fail.
+# Instead, they record the failure and allow the test to continue.
+# At the end of the test, you can call the assert_all method to raise an exception if any soft assertions failed.
+module SoftAssert
+  extend Minitest::Assertions
+
+  class << self
+    attr_accessor :assertions
+  end
+
+  @assertions = 0
+  @soft_errors = []
+
+  # Asserts that a boolean value is true.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_true(bool, message = nil)
+    Test::Unit::Assertions.assert_true(bool, message)
+  rescue Test::Unit::AssertionFailedError => e
+    @soft_errors << e
+  end
+
+  # Asserts that a boolean value is false.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_false(bool, message = nil)
+    Test::Unit::Assertions.assert_false(bool, message)
+  rescue Test::Unit::AssertionFailedError => e
+    @soft_errors << e
+  end
+
+  # Asserts that two values are equal.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_equal(expected, actual, message = nil)
+    Minitest::Assertions.assert_equal(expected, actual, message)
+  rescue Test::Unit::AssertionFailedError => e
+    @soft_errors << e
+  end
+
+  # Asserts that two values are not equal.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_not_equal(expected, actual, message = nil)
+    refute_equal(expected, actual, message)
+  rescue Minitest::Assertion => e
+    @soft_errors << e
+  end
+
+  # Asserts that a collection includes a certain value.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_contains(actual, expected, message = nil)
+    assert_includes(actual, expected, message)
+  rescue Minitest::Assertion => e
+    @soft_errors << e
+  end
+
+  # Asserts that a collection does not include a certain value.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_not_contains(actual, expected, message = nil)
+    refute_includes(actual, expected, message)
+  rescue Minitest::Assertion => e
+    @soft_errors << e
+  end
+
+  # Asserts that a collection is empty.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_empty(actual, message = nil)
+    Minitest::Assertions.assert_empty(actual, message)
+  rescue Test::Unit::AssertionFailedError => e
+    @soft_errors << e
+  end
+
+  # Asserts that a collection is not empty.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_not_empty(actual, message = nil)
+    refute_empty(actual, message)
+  rescue Minitest::Assertion => e
+    @soft_errors << e
+  end
+
+  # Asserts that a value is nil.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_nil(actual, message = nil)
+    Minitest::Assertions.assert_nil(actual, message)
+  rescue Test::Unit::AssertionFailedError => e
+    @soft_errors << e
+  end
+
+  # Asserts that a value is not nil.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_not_nil(actual, message = nil)
+    refute_nil(actual, message)
+  rescue Minitest::Assertion => e
+    @soft_errors << e
+  end
+
+  # Asserts that a string matches a regular expression.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_match(regex, actual, message = nil)
+    Minitest::Assertions.assert_match(regex, actual, message)
+  rescue Test::Unit::AssertionFailedError => e
+    @soft_errors << e
+  end
+
+  # Asserts that a string does not match a regular expression.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_not_match(regex, actual, message = nil)
+    refute_match(regex, actual, message)
+  rescue Minitest::Assertion => e
+    @soft_errors << e
+  end
+
+  # Asserts that two arrays are equal, after sorting them.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_array_equals(expected, actual, message = nil)
+    # Sort the arrays based on the string representation of each object
+    expected_sorted = expected.sort_by(&:to_s)
+    actual_sorted = actual.sort_by(&:to_s)
+
+    SoftAssert.assert_equal(expected_sorted, actual_sorted, message)
+  rescue Minitest::Assertion => e
+    @soft_errors << e
+  end
+
+  # Asserts that two arrays are equal, after sorting them.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_array_not_equals(expected, actual, message = nil)
+    # Sort the arrays based on the string representation of each object
+    expected_sorted = expected.sort_by(&:to_s)
+    actual_sorted = actual.sort_by(&:to_s)
+
+    refute_equal(expected_sorted, actual_sorted, message)
+  rescue Minitest::Assertion => e
+    @soft_errors << e
+  end
+
+  # Asserts that two hashes are equal, after sorting them.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_hash_equals(expected, actual, message = nil)
+    # Sort the hashes based on the string representation of each key-value pair
+    expected_sorted = expected.sort_by { |k, v| [k, v.to_s] }.to_h
+    actual_sorted = actual.sort_by { |k, v| [k, v.to_s] }.to_h
+
+    SoftAssert.assert_equal(expected_sorted, actual_sorted, message)
+  rescue Minitest::Assertion => e
+    @soft_errors << e
+  end
+
+  # Asserts that two hashes are not equal, after sorting them.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_hash_not_equals(expected, actual, message = nil)
+    # Sort the hashes based on the string representation of each key-value pair
+    expected_sorted = expected.sort_by { |k, v| [k, v.to_s] }.to_h
+    actual_sorted = actual.sort_by { |k, v| [k, v.to_s] }.to_h
+
+    refute_equal(expected_sorted, actual_sorted, message)
+  rescue Minitest::Assertion => e
+    @soft_errors << e
+  end
+
+  # Asserts that two maps are equal, after sorting them.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_map_equals(expected, actual, message = nil)
+    # Sort the hashes based on the string representation of each key-value pair
+    expected_sorted = expected.sort_by { |k, v| [k, v.to_s] }.to_h
+    actual_sorted = actual.sort_by { |k, v| [k, v.to_s] }.to_h
+
+    SoftAssert.assert_equal(expected_sorted, actual_sorted, message)
+  rescue Minitest::Assertion => e
+    @soft_errors << e
+  end
+
+  # Asserts that two maps are not equal, after sorting them.
+  # If the assertion fails, the error is recorded and the test continues.
+  def self.assert_map_not_equals(expected, actual, message = nil)
+    # Sort the hashes based on the string representation of each key-value pair
+    expected_sorted = expected.sort_by { |k, v| [k, v.to_s] }.to_h
+    actual_sorted = actual.sort_by { |k, v| [k, v.to_s] }.to_h
+
+    refute_equal(expected_sorted, actual_sorted, message)
+  rescue Minitest::Assertion => e
+    @soft_errors << e
+  end
+
+  # Raises an exception if any soft assertions have failed.
+  # This method should be called at the end of each test.
+  def self.assert_all
+    return if @soft_errors.empty?
+
+    errors = @soft_errors
+    @soft_errors = []
+    raise "Soft Assertion\n#{errors.join("\n\n")}\n"
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: soft-assert
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Ashitha Rao
+- Sumit Ghosh
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-09-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.20.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.20.0
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.1
+description: A set of assertion methods that do not stop the execution of the test
+  when they fail.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/soft_assert.rb
+homepage: https://github.com/AshithaRao/soft-assert-ruby/blob/main/README.md
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.6
+signing_key:
+specification_version: 4
+summary: Soft assertions for Ruby
+test_files: []