assert 2.18.0 → 2.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20bea593cdc98d699ba8e3cc3a946d178800c3e08afce5ccc19bc844851c8a1c
-  data.tar.gz: 3eb6857857d305066936768ff680d30449bb6ee2e5730805227ab0f8120465e9
+  metadata.gz: 9486fb389a6e45657eaf3c79f7c2cfea3e8cd6d9b8593c28597b716f9316c86b
+  data.tar.gz: dea0bd1b5061630fddad2f2feaa43e3faf0e64504bf444599747035b3ca8e40f
 SHA512:
-  metadata.gz: 67b54d007f1a3da01a789d9b5bf77fd8850fb21cb2997b41719c9ec88ad93ebe7a94a4b1874f85c81adc31c09818f5cdc44e20d39ea7488710a8bb09dba7562a
-  data.tar.gz: 17ce1c4d21f34fcb1b229c28fa5ff9685df1ab0a498116edcd5b8a637ba3cdb4e18e36813e957aa05dd113a22c96eca60ca9a9c5ecffc2484fd590b1bec5f56a
+  metadata.gz: c6e57f7df5c6b7273a3ccb190ecc77f014fe597fa15fb6cc72f4bdadd77a12066736e9dffc12cc02d4854f7cf92751fe1994d5142ad24c44eb196906eb079d64
+  data.tar.gz: cd2c4c0ef5c647abab8a9aac3340d17219ccd5b9d8eed5df34f47238296187122ee4b0df2c09aa9989e7dc8ddcb5d0529e3c615f539cf22e3e4f5d35a8b81575

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)
@@ -71,58 +72,86 @@ Assert comes with a stubbing API - all it does is replace method calls.  In gene
 * no methods are added to `Object` to support stubbing
 * stubs are auto-unstubbed on test teardown
 
-**Note**: Assert's stubbing logic has been extracted into a separate gem: [MuchStub](https://github.com/redding/much-stub/#muchstub).  However, the main `Assert.{stub|unstub|stub_send|etc}` api is still available (it just proxies MuchStub now).
+**Note**: Assert's stubbing logic has been extracted into a separate gem: [MuchStub](https://github.com/redding/much-stub/#muchstub).  However, the main `Assert.{stub|unstub|stub_send|stub_tap|etc}` api is still available (it just proxies to MuchStub now).
 
 ```ruby
 myclass = Class.new do
-  def mymeth; "meth"; end
-  def myval(val); val; end
+  def my_method
+    "my_method"
+  end
+
+  def my_value(value)
+    value
+  end
 end
-myobj = myclass.new
+my_object = myclass.new
 
-myobj.mymeth
-  # => "meth"
-myobj.myval(123)
+my_object.my_method
+  # => "my_method"
+my_object.my_value(123)
   # => 123
-myobj.myval(456)
+my_object.my_value(456)
   # => 456
 
-Assert.stub(myobj, :mymeth)
-myobj.mymeth
-  # => StubError: `mymeth` not stubbed.
-Assert.stub(myobj, :mymeth){ "stub-meth" }
-myobj.mymeth
+Assert.stub(my_object, :my_method)
+my_object.my_method
+  # => StubError: `my_method` not stubbed.
+Assert.stub(my_object, :my_method){ "stub-meth" }
+my_object.my_method
   # => "stub-meth"
-myobj.mymeth(123)
+my_object.my_method(123)
   # => StubError: arity mismatch
-Assert.stub(myobj, :mymeth).with(123){ "stub-meth" }
+Assert.stub(my_object, :my_method).with(123){ "stub-meth" }
   # => StubError: arity mismatch
-Assert.stub_send(myobj, :mymeth) # call to the original method post-stub
-  # => "meth"
 
-Assert.stub(myobj, :myval){ "stub-meth" }
+# Call the original method after it has been stubbed.
+Assert.stub_send(my_object, :my_method)
+  # => "my_method"
+
+Assert.stub(my_object, :my_value){ "stub-meth" }
   # => StubError: arity mismatch
-Assert.stub(myobj, :myval).with(123){ |val| val.to_s }
-myobj.myval
+Assert.stub(my_object, :my_value).with(123){ |val| val.to_s }
+my_object.my_value
   # => StubError: arity mismatch
-myobj.myval(123)
+my_object.my_value(123)
   # => "123"
-myobj.myval(456)
-  # => StubError: `myval(456)` not stubbed.
-Assert.stub_send(myobj, :myval, 123) # call to the original method post-stub
+my_object.my_value(456)
+  # => StubError: `my_value(456)` not stubbed.
+
+# Call the original method after it has been stubbed.
+Assert.stub_send(my_object, :my_value, 123)
   # => 123
-Assert.stub_send(myobj, :myval, 456)
+Assert.stub_send(my_object, :my_value, 456)
   # => 456
 
-Assert.unstub(myobj, :mymeth)
-Assert.unstub(myobj, :myval)
+# Stub a method while preserving its behavior and return value.
+my_value_called_with = nil
+Assert.stub_tap(my_object, :my_value) { |value, *args|
+  my_value_called_with = args
+  Assert.stub(value, :to_s) { "FIREWORKS!" }
+}
+value = my_object.my_value(123)
+  # => 123
+my_value_called_with
+  # => [123]
+value.to_s
+  # =>"FIREWORKS!"
+
+# Unstub individual stubs
+Assert.unstub(my_object, :my_method)
+Assert.unstub(my_object, :my_value)
+
+# OR blanket unstub all stubs
+Assert.unstub!
 
-myobj.mymeth
-  # => "meth"
-myobj.myval(123)
+my_object.my_method
+  # => "my_method"
+my_object.my_value(123)
   # => 123
-myobj.myval(456)
+value = my_object.my_value(456)
   # => 456
+value.to_s
+  # => "456"
 ```
 
 ## Factory
@@ -638,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

@@ -18,8 +18,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.required_ruby_version = "~> 2.4"
+  gem.required_ruby_version = "~> 2.5"
 
-  gem.add_dependency("much-factory", ["~> 0.1.0"])
-  gem.add_dependency("much-stub",    ["~> 0.1.1"])
+  gem.add_dependency("much-factory",   ["~> 0.1.0"])
+  gem.add_dependency("much-not-given", ["~> 0.1.0"])
+  gem.add_dependency("much-stub",      ["~> 0.1.4"])
 end

data/lib/assert/actual_value.rb

@@ -0,0 +1,140 @@
+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/assertions.rb

@@ -2,6 +2,15 @@ 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 +34,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 +49,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 +198,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 +322,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__