assert 2.18.2 → 2.19.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93616ac8a1849d9f356088b0386907f946cf89465e84aaa6321ceff60f7012de
-  data.tar.gz: a4436d1c9d437cb56343318885b1a32d804ad2e71c956408cd877d695f3d9675
+  metadata.gz: e3b20f41e3b589e8ae182a0da975229922e825b024d4bd8e35d886345728e6e7
+  data.tar.gz: 5e2c9057744017ab8a1da1033a15f5c3b3fab0b93f62b7b9aa9fc2bcf07f5cdf
 SHA512:
-  metadata.gz: 424110cb0d83c44fcdc66129532bc53859a74a0b2f63f2b08081955d6aee813a9df11f37afbdc325f464866ca0263fc98164992d08949fa2573410f9056334c6
-  data.tar.gz: 25b2980b91b9e4dddf9724f64cbdc81214c910008157f0ac88f3e3a1c6f4ae8162065d08ef4a2c2eb78ff2211cdc49fdac893397e50e04b5816174eb8293c01b
+  metadata.gz: 250ff1cbe8a89cadf674b2cb15d4ec2dce7d3de676c69b3462d06b12a4c4230766fe9a35d1ea5c1599fb7045b4cdf25c4e3d99cf862ea45bf70f20d354d073ab
+  data.tar.gz: de2c80f03461272a22c8f5f89f45e753fce2b0cadaed129f94b7fb3c7916df5aae1a14dec0cef2f0b37bb14e23e6898dc4a569cd7ed4a0cc9dad0adf78fde8cd

data/Gemfile

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
-ruby "~>2.4"
+ruby "~> 2.5"
 
 gemspec
 
-gem "pry", "~> 0.12.2"
+gem "pry"

data/README.md

@@ -9,7 +9,7 @@ require "assert"
 
 class MyTests < Assert::Context
   test "something" do
-    assert_equal 1, 1
+    assert_that(1).equals(1)
   end
 end
 ```
@@ -33,13 +33,13 @@ Running tests in random order, seeded with "56382"
 
 ## What Assert is not
 
-* **RSpec/spec-anything**: define tests using assertion statements
-* **Unit/Functional/Integration/etc**: Assert is agnostic - you define whatever kinds of tests you like (one or more of the above) and assert runs them in context
-* **Mock/Spec/BDD/etc**: Assert is the framework and there are a variety of 3rd party tools to do such things - feel free to use whatever you like
+* **RSpec/spec-anything**: define tests using assertion statements.
+* **Unit/Functional/Integration/etc**: Assert is agnostic - you define whatever kinds of tests you like and Assert runs them in context.
+* **Mock/Spec/BDD/etc**: Assert is the framework and there are a variety of 3rd party tools to do such things. Feel free to use whatever you like.
 
 ## Description
 
-Assert is an assertion style testing framework, meaning you use assertion statements to define your tests and create results.  Assert uses class-based contexts so if you want to nest your contexts, use inheritance.
+Assert is an assertion-style testing framework, meaning you use assertion statements to define your tests and create results. Assert uses class-based contexts so if you want to nest your contexts, use inheritance.
 
 ### Features
 
@@ -50,6 +50,7 @@ Assert is an assertion style testing framework, meaning you use assertion statem
 * class-based contexts
 * multiple before/setup & after/teardown blocks
 * around blocks
+* `let` value declarations
 * full backtrace for errors
 * optionally pretty print objects in failure descriptions
 * [stubbing API](https://github.com/redding/assert#stub)
@@ -666,4 +667,4 @@ If submitting a Pull Request, please:
 
 One note: please respect that Assert itself is intended to be the flexible, base-level, framework-type logic that should change little if at all.  Pull requests for niche functionality or personal testing philosphy stuff will likely not be accepted.
 
-If you wish to extend Assert for your niche purpose/desire/philosophy, please do so in it's own gem (preferrably named `assert-<whatever>`) that uses Assert as a dependency.
+If you wish to extend Assert for your niche purpose/desire/philosophy, please do so in its own gem (preferrably named `assert-<whatever>`) that uses Assert as a dependency.

data/assert.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -*- encoding: utf-8 -*-
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
@@ -20,6 +22,7 @@ Gem::Specification.new do |gem|
 
   gem.required_ruby_version = "~> 2.5"
 
-  gem.add_dependency("much-factory", ["~> 0.1.0"])
-  gem.add_dependency("much-stub",    ["~> 0.1.3"])
+  gem.add_dependency("much-factory",   ["~> 0.2.0"])
+  gem.add_dependency("much-not-given", ["~> 0.1.1"])
+  gem.add_dependency("much-stub",      ["~> 0.1.6"])
 end

data/bin/assert

@@ -2,6 +2,7 @@
 #
 # Copyright (c) 2011-Present Kelly Redding and Collin Redding
 #
+# frozen_string_literal: true
 
 require "assert"
 require "assert/cli"

data/lib/assert.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert/version"
 
 require "assert/config"

data/lib/assert/actual_value.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "much-not-given"
+require "much-stub"
+
+module Assert; end
+
+class Assert::ActualValue
+  include MuchNotGiven
+
+  def initialize(value = self.class.not_given, context:, &value_block)
+    @value = self.class.given?(value) ? value : value_block
+    @context = context
+  end
+
+  def returns_true(*args)
+    @context.assert_block(*args, &@value)
+  end
+
+  def does_not_return_true(*args)
+    @context.assert_not_block(*args, &@value)
+  end
+
+  def raises(*expected_exceptions)
+    @context.assert_raises(*expected_exceptions, &@value)
+  end
+
+  def does_not_raise(*expected_exceptions)
+    @context.assert_nothing_raised(*expected_exceptions, &@value)
+  end
+
+  def changes(*args)
+    @context.assert_changes(*args, &@value)
+  end
+
+  def does_not_change(*args)
+    @context.assert_not_changes(*args, &@value)
+  end
+
+  def is_a_kind_of(expected_class, *args)
+    @context.assert_kind_of(expected_class, @value, *args)
+  end
+  alias_method :is_kind_of, :is_a_kind_of
+
+  def is_not_a_kind_of(expected_class, *args)
+    @context.assert_not_kind_of(expected_class, @value, *args)
+  end
+  alias_method :is_not_kind_of, :is_not_a_kind_of
+
+  def is_an_instance_of(expected_class, *args)
+    @context.assert_instance_of(expected_class, @value, *args)
+  end
+  alias_method :is_instance_of, :is_an_instance_of
+
+  def is_not_an_instance_of(expected_class, *args)
+    @context.assert_not_instance_of(expected_class, @value, *args)
+  end
+  alias_method :is_not_instance_of, :is_not_an_instance_of
+
+  def responds_to(expected_method_name, *args)
+    @context.assert_responds_to(expected_method_name, @value, *args)
+  end
+
+  def does_not_respond_to(expected_method_name, *args)
+    @context.assert_not_responds_to(expected_method_name, @value, *args)
+  end
+
+  def is_the_same_as(expected_object, *args)
+    @context.assert_same(expected_object, @value, *args)
+  end
+  alias_method :is, :is_the_same_as
+
+  def is_not_the_same_as(expected_object, *args)
+    @context.assert_not_same(expected_object, @value, *args)
+  end
+  alias_method :is_not, :is_not_the_same_as
+
+  def equals(expected_value, *args)
+    @context.assert_equal(expected_value, @value, *args)
+  end
+  alias_method :is_equal_to, :equals
+
+  def does_not_equal(expected_value, *args)
+    @context.assert_not_equal(expected_value, @value, *args)
+  end
+  alias_method :is_not_equal_to, :does_not_equal
+
+  def matches(expected_regex, *args)
+    @context.assert_match(expected_regex, @value, *args)
+  end
+
+  def does_not_match(expected_regex, *args)
+    @context.assert_not_match(expected_regex, @value, *args)
+  end
+
+  def is_empty(*args)
+    @context.assert_empty(@value, *args)
+  end
+
+  def is_not_empty(*args)
+    @context.assert_not_empty(@value, *args)
+  end
+
+  def includes(object, *args)
+    @context.assert_includes(object, @value, *args)
+  end
+
+  def does_not_include(object, *args)
+    @context.assert_not_includes(object, @value, *args)
+  end
+
+  def is_nil(*args)
+    @context.assert_nil(@value, *args)
+  end
+
+  def is_not_nil(*args)
+    @context.assert_not_nil(@value, *args)
+  end
+
+  def is_true(*args)
+    @context.assert_true(@value, *args)
+  end
+
+  def is_not_true(*args)
+    @context.assert_not_true(@value, *args)
+  end
+
+  def is_false(*args)
+    @context.assert_false(@value, *args)
+  end
+
+  def is_not_false(*args)
+    @context.assert_not_false(@value, *args)
+  end
+
+  def is_a_file(*args)
+    @context.assert_file_exists(@value, *args)
+  end
+
+  def is_not_a_file(*args)
+    @context.assert_not_file_exists(@value, *args)
+  end
+end

data/lib/assert/assert_runner.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert/cli"
 
 module Assert

data/lib/assert/assertions.rb

@@ -1,7 +1,18 @@
+# frozen_string_literal: true
+
 require "assert/utils"
 
 module Assert
   module Assertions
+    IGNORED_ASSERTION_HELPERS =
+      [
+        :assert_throws,     :assert_nothing_thrown,
+        :assert_operator,   :refute_operator,
+        :assert_in_epsilon, :refute_in_epsilon,
+        :assert_in_delta,   :refute_in_delta,
+        :assert_send
+      ]
+
     def assert_block(desc = nil)
       assert(yield, desc){ "Expected block to return a true value." }
     end
@@ -25,7 +36,7 @@ module Assert
     alias_method :refute_empty, :assert_not_empty
 
     def assert_equal(exp, act, desc = nil)
-      assert(exp == act, desc) do
+      assert(act == exp, desc) do
         c = __assert_config__
         exp_show = Assert::U.show_for_diff(exp, c)
         act_show = Assert::U.show_for_diff(act, c)
@@ -40,7 +51,7 @@ module Assert
     end
 
     def assert_not_equal(exp, act, desc = nil)
-      assert(exp != act, desc) do
+      assert(act != exp, desc) do
         c = __assert_config__
         exp_show = Assert::U.show_for_diff(exp, c)
         act_show = Assert::U.show_for_diff(act, c)
@@ -189,6 +200,75 @@ module Assert
     alias_method :assert_not_raises, :assert_nothing_raised
     alias_method :assert_not_raise, :assert_nothing_raised
 
+    def assert_changes(
+          ruby_string_to_eval,
+          desc: nil,
+          from: Assert::ActualValue.not_given,
+          to: Assert::ActualValue.not_given,
+          &block
+        )
+      desc_msg = desc ? "#{desc}\n" : ""
+      from_eval = instance_eval(ruby_string_to_eval)
+      if Assert::ActualValue.given?(from)
+        assert_equal(
+          from,
+          from_eval,
+          "#{desc_msg}Expected `#{ruby_string_to_eval}` to change from `#{from.inspect}`."
+        )
+      end
+
+      block.call
+
+      to_eval = instance_eval(ruby_string_to_eval)
+      if Assert::ActualValue.given?(to)
+        assert_equal(
+          to,
+          to_eval,
+          "#{desc_msg}Expected `#{ruby_string_to_eval}` to change to `#{to.inspect}`."
+        )
+      end
+
+      if (
+        Assert::ActualValue.not_given?(from) &&
+        Assert::ActualValue.not_given?(to)
+      )
+        assert_not_equal(
+          from_eval,
+          to_eval,
+          "#{desc_msg}Expected `#{ruby_string_to_eval}` to change; "\
+          "it was `#{from_eval.inspect}` and didn't change."
+        )
+      end
+    end
+
+    def assert_not_changes(
+          ruby_string_to_eval,
+          desc: nil,
+          from: Assert::ActualValue.not_given,
+          &block
+        )
+      desc_msg = desc ? "#{desc}\n" : ""
+      from_eval = instance_eval(ruby_string_to_eval)
+      if Assert::ActualValue.given?(from)
+        assert_equal(
+          from,
+          from_eval,
+          "#{desc_msg}Expected `#{ruby_string_to_eval}` to not change from `#{from.inspect}`."
+        )
+      end
+
+      block.call
+
+      to_eval = instance_eval(ruby_string_to_eval)
+      assert_equal(
+        from_eval,
+        to_eval,
+        "#{desc_msg}Expected `#{ruby_string_to_eval}` to not change; "\
+        "it was `#{from_eval.inspect}` and changed to `#{to_eval.inspect}`."
+      )
+    end
+    alias_method :refute_changes, :assert_not_changes
+
     def assert_respond_to(method, object, desc = nil)
       assert(object.respond_to?(method), desc) do
         "Expected #{Assert::U.show(object, __assert_config__)} (#{object.class})"\
@@ -244,24 +324,6 @@ module Assert
     end
     alias_method :refute_same, :assert_not_same
 
-    # ignored assertion helpers
-
-    IGNORED_ASSERTION_HELPERS = [
-      :assert_throws,     :assert_nothing_thrown,
-      :assert_operator,   :refute_operator,
-      :assert_in_epsilon, :refute_in_epsilon,
-      :assert_in_delta,   :refute_in_delta,
-      :assert_send
-    ]
-    def method_missing(method, *args, &block)
-      if IGNORED_ASSERTION_HELPERS.include?(method.to_sym)
-        ignore "The assertion `#{method}` is not supported."\
-               " Please use another assertion or the basic `assert`."
-      else
-        super
-      end
-    end
-
     private
 
     def __assert_config__

data/lib/assert/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "benchmark"
 require "set"
 require "assert/assert_runner"

data/lib/assert/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert/default_runner"
 require "assert/default_suite"
 require "assert/default_view"

data/lib/assert/config_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Assert
   module ConfigHelpers
     def runner; self.config.runner; end

data/lib/assert/context.rb

@@ -1,4 +1,9 @@
+# frozen_string_literal: true
+
+require "assert/actual_value"
 require "assert/assertions"
+require "assert/context/let_dsl"
+require "assert/context/method_missing"
 require "assert/context/setup_dsl"
 require "assert/context/subject_dsl"
 require "assert/context/suite_dsl"
@@ -10,42 +15,22 @@ require "assert/suite"
 require "assert/utils"
 
 module Assert
+  # A Context is a scope for tests to run in. Contexts have setup and teardown
+  # blocks, subjects, and descriptions. Tests are run in the scope of a Context
+  # instance. Therefore, a Context should have minimal base
+  # logic/methods/instance_vars. The instance should remain pure to not pollute
+  # test scopes.
   class Context
-    # put all logic in DSL methods to keep context instances pure for running tests
+    # Put all logic in DSL methods to keep context instances pure.
     extend SetupDSL
     extend SubjectDSL
     extend SuiteDSL
     extend TestDSL
+    extend LetDSL
+    include MethodMissing
     include Assert::Assertions
     include Assert::Macros::Methods
 
-    # a Context is a scope for tests to run in.  Contexts have setup and
-    # teardown blocks, subjects, and descriptions.  Tests are run in the
-    # scope of a Context instance.  Therefore, a Context should have
-    # minimal base logic/methods/instance_vars.  The instance should remain
-    # pure to not pollute test scopes.
-
-    # if a test method is added to a context manually (not using a context helper):
-    # capture any context info, build a test obj, and add it to the suite
-    def self.method_added(method_name)
-      if method_name.to_s =~ Suite::TEST_METHOD_REGEX
-        klass_method_name = "#{self}##{method_name}"
-
-        if self.suite.test_methods.include?(klass_method_name)
-          puts "WARNING: redefining "#{klass_method_name}""
-          puts "  from: #{caller_locations(1,1)}"
-        else
-          self.suite.test_methods << klass_method_name
-        end
-
-        self.suite.on_test(Test.for_method(
-          method_name.to_s,
-          ContextInfo.new(self, nil, caller_locations(1,1)),
-          self.suite.config
-        ))
-      end
-    end
-
     def initialize(running_test, config, result_callback)
       @__assert_running_test__ = running_test
       @__assert_config__       = config
@@ -61,9 +46,8 @@ module Assert
       end
     end
 
-    # check if the assertion is a truthy value, if so create a new pass result,
-    # otherwise create a new fail result with the desc and what failed msg.
-    # all other assertion helpers use this one in the end
+    # Check if the result is true. If so, create a new pass result,  Otherwise
+    # create a new fail result with the desc and fail msg.
     def assert(assertion, desc = nil)
       if assertion
         pass
@@ -78,8 +62,8 @@ module Assert
       end
     end
 
-    # the opposite of assert, check if the assertion is a false value, if so create a new pass
-    # result, otherwise create a new fail result with the desc and it's what failed msg
+    # The opposite of assert. Check if the result is false. If so, create a new
+    # pass result. Otherwise create a new fail result with the desc and fail msg.
     def assert_not(assertion, fail_desc = nil)
       assert(!assertion, fail_desc) do
         "Failed assert_not: assertion was "\
@@ -88,14 +72,23 @@ module Assert
     end
     alias_method :refute, :assert_not
 
+    def assert_that(
+          actual_value = Assert::ActualValue.not_given,
+          &actual_value_block
+        )
+      Assert::ActualValue.new(actual_value, context: self, &actual_value_block)
+    end
+
     # adds a Pass result to the end of the test's results
     # does not break test execution
     def pass(pass_msg = nil)
       if @__assert_pending__ == 0
         capture_result(Assert::Result::Pass, pass_msg)
       else
-        capture_result(Assert::Result::Fail, "Pending pass (make it "\
-                                             "not pending)")
+        capture_result(
+          Assert::Result::Fail,
+          "Pending pass (make it not pending)"
+        )
       end
     end
 
@@ -157,9 +150,12 @@ module Assert
     end
 
     def subject
-      if subj = self.class.subject
-        instance_eval(&subj)
+      unless instance_variable_defined?("@__assert_subject__")
+        @__assert_subject__ =
+          instance_eval(&self.class.subject) if self.class.subject
       end
+
+      @__assert_subject__
     end
 
     def inspect