assert 2.18.3 → 2.19.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff0d6ff9233adc09dda972e165c47c125e158e46b0329b927eb7de201ddebf65
-  data.tar.gz: 8f77b5326cf44e2ed0c7ed72cac390a7147191634354feb2b890f73d572b366f
+  metadata.gz: 34f566e486dd95320eeb65a2d4599a607df3aa3762901c1de08363c3ec7b5af8
+  data.tar.gz: f6c7cb0a7a6524c75500625eaba0df9b82387174ce7644cdfa9fd8243162a950
 SHA512:
-  metadata.gz: 25b58fd65c099c0c9f8ff16a652e28d5baeae76838b640872224abd7d063759d6fd40b3ec927220260d82321f78cc4b7617d50a081c7ba336b04d45acec8f618
-  data.tar.gz: 669749ff845ae1811802042dd28e27e7a387d9d39a9504d73b8b04667c9597c4da08bd56cc26a7b34838e5afde2970215027a7d3967ad1e7f99175c62c49a08e
+  metadata.gz: b2f75956fadc6203797376fbc3763084068a7fc4b28966f3914029395d5d23212edf35ce2700e99d64a086c8791aad9bfa4c2cf75f9fcc66fb20437a67c97f41
+  data.tar.gz: '075696b82759d6a4b0ec838b16e311bb9d91368a7bf9f00f577be210285db3fb8a58c313e9298f0aae4c3abb81f489ed6f93f00ef3aba1faf41491dbd2ff5f46'

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/assert.gemspec

@@ -1,4 +1,6 @@
 # -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "assert/version"
@@ -8,18 +10,22 @@ Gem::Specification.new do |gem|
   gem.version     = Assert::VERSION
   gem.authors     = ["Kelly Redding", "Collin Redding"]
   gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
-  gem.summary     = %q{Assertion style testing framework.}
-  gem.description = %q{Assertion style testing framework.}
+  gem.summary     = "Assertion style testing framework."
+  gem.description = "Assertion style testing framework."
   gem.homepage    = "http://github.com/redding/assert"
   gem.license     = "MIT"
 
-  gem.files         = `git ls-files | grep "^[^.]"`.split($/)
+  gem.files = `git ls-files | grep "^[^.]"`.split($INPUT_RECORD_SEPARATOR)
+
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
   gem.required_ruby_version = "~> 2.5"
 
-  gem.add_dependency("much-factory", ["~> 0.1.0"])
-  gem.add_dependency("much-stub",    ["~> 0.1.4"])
+  gem.add_development_dependency("much-style-guide", ["~> 0.5.0"])
+
+  gem.add_dependency("much-factory",   ["~> 0.2.1"])
+  gem.add_dependency("much-not-given", ["~> 0.1.2"])
+  gem.add_dependency("much-stub",      ["~> 0.1.7"])
 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"
@@ -9,16 +11,28 @@ require "assert/utils"
 require "assert/view"
 
 module Assert
-  def self.config; @config ||= Config.new; end
-  def self.configure; yield self.config if block_given?; end
+  def self.config
+    @config ||= Config.new
+  end
+
+  def self.configure
+    yield config if block_given?
+  end
+
+  def self.view
+    config.view
+  end
 
-  def self.view;   self.config.view;   end
-  def self.suite;  self.config.suite;  end
-  def self.runner; self.config.runner; end
+  def self.suite
+    config.suite
+  end
+
+  def self.runner
+    config.runner
+  end
 
   # unstub all stubs automatically (see stub.rb)
   class Context
     teardown{ Assert.unstub! }
   end
 end
-

data/lib/assert/actual_value.rb

@@ -1,9 +1,15 @@
+# frozen_string_literal: true
+
+require "much-not-given"
 require "much-stub"
 
 module Assert; end
+
 class Assert::ActualValue
-  def initialize(value, context:)
-    @value = value
+  include MuchNotGiven
+
+  def initialize(value = self.class.not_given, context:, &value_block)
+    @value = self.class.given?(value) ? value : value_block
     @context = context
   end
 
@@ -23,15 +29,25 @@ class Assert::ActualValue
     @context.assert_nothing_raised(*expected_exceptions, &@value)
   end
 
-  def is_a_kind_of(expected_class, *args)
-    @context.assert_kind_of(expected_class, @value, *args)
+  def changes(*args)
+    @context.assert_changes(*args, &@value)
+  end
+
+  def does_not_change(*args)
+    @context.assert_not_changes(*args, &@value)
+  end
+
+  def is_a(expected_class, *args)
+    @context.assert_is_a(expected_class, @value, *args)
   end
-  alias_method :is_kind_of, :is_a_kind_of
+  alias_method :is_a_kind_of, :is_a
+  alias_method :is_kind_of, :is_a
 
-  def is_not_a_kind_of(expected_class, *args)
-    @context.assert_not_kind_of(expected_class, @value, *args)
+  def is_not_a(expected_class, *args)
+    @context.assert_is_not_a(expected_class, @value, *args)
   end
-  alias_method :is_not_kind_of, :is_not_a_kind_of
+  alias_method :is_not_a_kind_of, :is_not_a
+  alias_method :is_not_kind_of, :is_not_a
 
   def is_an_instance_of(expected_class, *args)
     @context.assert_instance_of(expected_class, @value, *args)
@@ -54,10 +70,12 @@ class Assert::ActualValue
   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)

data/lib/assert/assert_runner.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert/cli"
 
 module Assert
@@ -23,24 +25,29 @@ module Assert
 
     def init(test_files, test_dir)
       # load any test helper file
-      if test_dir && (h = File.join(test_dir, self.config.test_helper)) && File.exists?(h)
+      if (
+        test_dir &&
+        (h = File.join(test_dir, config.test_helper)) &&
+        File.exist?(h)
+      )
         Assert::CLI.bench("Requiring test helper"){ require h }
       end
 
-      if self.config.list
+      if config.list
         $stdout.puts test_files
         halt
       end
 
       # load the test files
-      runner, suite, view = self.config.runner, self.config.suite, self.config.view
+      runner, suite, view =
+        config.runner, config.suite, config.view
       runner.before_load(test_files)
       suite.before_load(test_files)
       view.before_load(test_files)
       Assert::CLI.bench("Requiring #{test_files.size} test files") do
         test_files.each{ |p| require p }
       end
-      if self.config.debug
+      if config.debug
         puts Assert::CLI.debug_msg("Test files:")
         test_files.each{ |f| puts Assert::CLI.debug_msg("  #{f}") }
       end
@@ -50,7 +57,7 @@ module Assert
     end
 
     def run
-      self.config.runner.run
+      config.runner.run
     end
 
     private
@@ -64,22 +71,27 @@ module Assert
     end
 
     def apply_local_settings
-      safe_require(ENV["ASSERT_LOCALFILE"] || path_of(LOCAL_SETTINGS_FILE, Dir.pwd))
+      safe_require(
+        ENV["ASSERT_LOCALFILE"] ||
+        path_of(LOCAL_SETTINGS_FILE, Dir.pwd),
+      )
     end
 
     def apply_env_settings
-      self.config.runner_seed ENV["ASSERT_RUNNER_SEED"].to_i if ENV["ASSERT_RUNNER_SEED"]
+      if ENV["ASSERT_RUNNER_SEED"]
+        config.runner_seed ENV["ASSERT_RUNNER_SEED"].to_i
+      end
     end
 
     def apply_option_settings(options)
-      self.config.apply(options)
+      config.apply(options)
     end
 
     def lookup_test_files(test_paths)
-      file_paths = if self.config.changed_only
+      file_paths = if config.changed_only
         changed_test_files(test_paths)
-      elsif self.config.single_test?
-        globbed_test_files([self.config.single_test_file_path])
+      elsif config.single_test?
+        globbed_test_files([config.single_test_file_path])
       else
         globbed_test_files(test_paths)
       end
@@ -88,33 +100,42 @@ module Assert
     end
 
     def changed_test_files(test_paths)
-      globbed_test_files(self.config.changed_proc.call(self.config, test_paths))
+      globbed_test_files(config.changed_proc.call(config, test_paths))
     end
 
     def globbed_test_files(test_paths)
       test_paths.inject(Set.new) do |paths, path|
         p = File.expand_path(path, Dir.pwd)
-        paths += Dir.glob("#{p}*") + Dir.glob("#{p}*/**/*")
+        paths + Dir.glob("#{p}*") + Dir.glob("#{p}*/**/*")
       end
     end
 
     def is_test_file?(path)
-      self.config.test_file_suffixes.inject(false) do |result, suffix|
+      config.test_file_suffixes.inject(false) do |result, suffix|
         result || path =~ /#{suffix}$/
       end
     end
 
     def safe_require(settings_file)
-      require settings_file if File.exists?(settings_file)
+      require settings_file if File.exist?(settings_file)
     end
 
     def path_of(segment, a_path)
       # this method inspects a test path and finds the test dir path.
       full_path = File.expand_path(a_path || ".", Dir.pwd)
       seg_pos = full_path.index(segment_regex(segment))
-      File.join(seg_pos && (seg_pos > 0) ? full_path[0..(seg_pos-1)] : full_path, segment)
+      File.join(
+        if seg_pos && (seg_pos > 0)
+          full_path[0..(seg_pos - 1)]
+        else
+          full_path
+        end,
+        segment,
+      )
     end
 
-    def segment_regex(seg); /^#{seg}$|^#{seg}\/|\/#{seg}\/|\/#{seg}$/; end
+    def segment_regex(seg)
+      %r{^#{seg}$|^#{seg}/|/#{seg}/|/#{seg}$}
+    end
   end
 end

data/lib/assert/assertions.rb

@@ -1,14 +1,20 @@
+# 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
+        :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)
@@ -22,13 +28,15 @@ module Assert
 
     def assert_empty(collection, desc = nil)
       assert(collection.empty?, desc) do
-        "Expected #{Assert::U.show(collection, __assert_config__)} to be empty."
+        "Expected #{Assert::U.show(collection, __assert_config__)} to "\
+        "be empty."
       end
     end
 
     def assert_not_empty(collection, desc = nil)
       assert(!collection.empty?, desc) do
-        "Expected #{Assert::U.show(collection, __assert_config__)} to not be empty."
+        "Expected #{Assert::U.show(collection, __assert_config__)} to "\
+        "not be empty."
       end
     end
     alias_method :refute_empty, :assert_not_empty
@@ -43,7 +51,8 @@ module Assert
           "Expected does not equal actual, diff:\n"\
           "#{c.run_diff_proc.call(exp_show, act_show)}"
         else
-          "Expected #{Assert::U.show(act, c)} to be equal to #{Assert::U.show(exp, c)}."
+          "Expected #{Assert::U.show(act, c)} to "\
+          "be equal to #{Assert::U.show(exp, c)}."
         end
       end
     end
@@ -58,20 +67,21 @@ module Assert
           "Expected equals actual, diff:\n"\
           "#{c.run_diff_proc.call(exp_show, act_show)}"
         else
-          "Expected #{Assert::U.show(act, c)} to not be equal to #{Assert::U.show(exp, c)}."
+          "Expected #{Assert::U.show(act, c)} to "\
+          "not be equal to #{Assert::U.show(exp, c)}."
         end
       end
     end
     alias_method :refute_equal, :assert_not_equal
 
     def assert_file_exists(file_path, desc = nil)
-      assert(File.exists?(File.expand_path(file_path)), desc) do
+      assert(File.exist?(File.expand_path(file_path)), desc) do
         "Expected #{Assert::U.show(file_path, __assert_config__)} to exist."
       end
     end
 
     def assert_not_file_exists(file_path, desc = nil)
-      assert(!File.exists?(File.expand_path(file_path)), desc) do
+      assert(!File.exist?(File.expand_path(file_path)), desc) do
         "Expected #{Assert::U.show(file_path, __assert_config__)} to not exist."
       end
     end
@@ -97,36 +107,41 @@ module Assert
 
     def assert_instance_of(klass, instance, desc = nil)
       assert(instance.instance_of?(klass), desc) do
-        "Expected #{Assert::U.show(instance, __assert_config__)} (#{instance.class})"\
-        " to be an instance of #{klass}."
+        "Expected #{Assert::U.show(instance, __assert_config__)} "\
+        "(#{instance.class}) to be an instance of #{klass}."
       end
     end
 
     def assert_not_instance_of(klass, instance, desc = nil)
       assert(!instance.instance_of?(klass), desc) do
-        "Expected #{Assert::U.show(instance, __assert_config__)} (#{instance.class})"\
-        " to not be an instance of #{klass}."
+        "Expected #{Assert::U.show(instance, __assert_config__)} "\
+        "(#{instance.class}) to not be an instance of #{klass}."
       end
     end
     alias_method :refute_instance_of, :assert_not_instance_of
 
-    def assert_kind_of(klass, instance, desc = nil)
-      assert(instance.kind_of?(klass), desc) do
-        "Expected #{Assert::U.show(instance, __assert_config__)} (#{instance.class})"\
-        " to be a kind of #{klass}."
+    def assert_is_a(klass, instance, desc = nil)
+      assert(instance.is_a?(klass), desc) do
+        "Expected #{Assert::U.show(instance, __assert_config__)} "\
+        "(#{instance.class}) to be a `#{klass}`."
       end
     end
+    alias_method :assert_kind_of, :assert_is_a
 
-    def assert_not_kind_of(klass, instance, desc = nil)
-      assert(!instance.kind_of?(klass), desc) do
-        "Expected #{Assert::U.show(instance, __assert_config__)} (#{instance.class})"\
-        " to not be a kind of #{klass}."
+    def assert_is_not_a(klass, instance, desc = nil)
+      assert(!instance.is_a?(klass), desc) do
+        "Expected #{Assert::U.show(instance, __assert_config__)} "\
+        "(#{instance.class}) to not be a `#{klass}`."
       end
     end
-    alias_method :refute_kind_of, :assert_not_kind_of
+    alias_method :assert_not_a, :assert_is_not_a
+    alias_method :assert_not_kind_of, :assert_is_not_a
+    alias_method :refute_is_a, :assert_is_not_a
+    alias_method :refute_kind_of, :assert_is_not_a
 
     def assert_match(exp, act, desc = nil)
-      exp_regex = String === exp && String === act ? /#{Regexp.escape(exp)}/ : exp
+      exp_regex =
+        String === exp && String === act ? /#{Regexp.escape(exp)}/ : exp
       assert(act =~ exp_regex, desc) do
         "Expected #{Assert::U.show(act, __assert_config__)}"\
         " to match #{Assert::U.show(exp, __assert_config__)}."
@@ -183,7 +198,7 @@ module Assert
     alias_method :refute_false, :assert_not_false
 
     def assert_raises(*exceptions, &block)
-      desc = exceptions.last.kind_of?(String) ? exceptions.pop : nil
+      desc = exceptions.last.is_a?(String) ? exceptions.pop : nil
       err = RaisedException.new(exceptions, &block)
       assert(err.raised?, desc){ err.msg }
       err.exception
@@ -191,25 +206,95 @@ module Assert
     alias_method :assert_raise, :assert_raises
 
     def assert_nothing_raised(*exceptions, &block)
-      desc = exceptions.last.kind_of?(String) ? exceptions.pop : nil
+      desc = exceptions.last.is_a?(String) ? exceptions.pop : nil
       err = NoRaisedException.new(exceptions, &block)
       assert(!err.raised?, desc){ err.msg }
     end
     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})"\
-        " to respond to `#{method}`."
+        "Expected #{Assert::U.show(object, __assert_config__)} "\
+        "(#{object.class}) to respond to `#{method}`."
       end
     end
     alias_method :assert_responds_to, :assert_respond_to
 
     def assert_not_respond_to(method, object, desc = nil)
       assert(!object.respond_to?(method), desc) do
-        "Expected #{Assert::U.show(object, __assert_config__)} (#{object.class})"\
-        " to not respond to `#{method}`."
+        "Expected #{Assert::U.show(object, __assert_config__)} "\
+        "(#{object.class}) to not respond to `#{method}`."
       end
     end
     alias_method :assert_not_responds_to, :assert_not_respond_to
@@ -228,8 +313,8 @@ module Assert
           "Expected #{act_id} to be the same as #{exp_id}, diff:\n"\
           "#{c.run_diff_proc.call(exp_show, act_show)}"
         else
-          "Expected #{Assert::U.show(act, c)} (#{act_id}) to be the same as"\
-          " #{Assert::U.show(exp, c)} (#{exp_id})."
+          "Expected #{Assert::U.show(act, c)} (#{act_id}) to "\
+          "be the same as #{Assert::U.show(exp, c)} (#{exp_id})."
         end
       end
     end
@@ -246,8 +331,8 @@ module Assert
           "Expected #{act_id} to not be the same as #{exp_id}, diff:\n"\
           "#{c.run_diff_proc.call(exp_show, act_show)}"
         else
-          "Expected #{Assert::U.show(act, c)} (#{act_id}) to not be the same as"\
-          " #{Assert::U.show(exp, c)} (#{exp_id})."
+          "Expected #{Assert::U.show(act, c)} (#{act_id}) to "\
+          "not be the same as #{Assert::U.show(exp, c)} (#{exp_id})."
         end
       end
     end
@@ -266,7 +351,16 @@ module Assert
 
       def initialize(exceptions, &block)
         @exceptions = exceptions
-        begin; block.call; rescue Exception => @exception; end
+        # rubocop:disable Lint/SuppressedException
+        # rubocop:disable Lint/RescueException
+        # rubocop:disable Naming/RescuedExceptionsVariableName
+        begin
+          block.call
+        rescue Exception => @exception
+        end
+        # rubocop:enable Lint/SuppressedException
+        # rubocop:enable Lint/RescueException
+        # rubocop:enable Naming/RescuedExceptionsVariableName
         @msg = "#{exceptions_sentence(@exceptions)} #{exception_details}"
       end
 
@@ -278,7 +372,11 @@ module Assert
 
       def is_one_of?(exception, exceptions)
         exceptions.empty? || exceptions.any? do |exp|
-          exp.instance_of?(Module) ? exception.kind_of?(exp) : exception.class == exp
+          if exp.instance_of?(Module)
+            exception.is_a?(exp)
+          else
+            exception.class == exp
+          end
         end
       end
 
@@ -293,13 +391,16 @@ module Assert
       def exception_details(raised_msg = nil, no_raised_msg = nil)
         if @exception
           backtrace = Assert::Result::Backtrace.new(@exception.backtrace)
-          [ raised_msg,
+          [
+            raised_msg,
             "Class: `#{@exception.class}`",
             "Message: `#{@exception.message.inspect}`",
             "---Backtrace---",
             backtrace.filtered.to_s,
-            "---------------"
-          ].compact.join("\n")
+            "---------------",
+          ]
+            .compact
+            .join("\n")
         else
           no_raised_msg
         end
@@ -308,7 +409,10 @@ module Assert
 
     class RaisedException < CheckException
       def exception_details
-        super("exception expected, not:", "exception expected but nothing raised.")
+        super(
+          "exception expected, not:",
+          "exception expected but nothing raised."
+        )
       end
     end