assert 2.17.0 → 2.18.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f64c7aa2c506b0fcf989763e437a103dd5401213f88bce9b7f4e7712db7fbe0
-  data.tar.gz: 3f5c30459a2528888dc24e356e626939e1fd204e1d287f06bbedf909c2d7eee9
+  metadata.gz: 7ed950be1bca18deac9277678d40abc99072df13d5e23d21460c7e9b72a1c4ab
+  data.tar.gz: cd7c0eec0a939400f384c6e8d69b7fbb27856f3ed9fdfca25ae1ab48404c822f
 SHA512:
-  metadata.gz: 6e9f3644f6c86856e3fd5c13560ecd6f7cadf194b158ccb3526267476745de34ca8ac87968cc5bf5f8d08d690a8cea40547e2a4dace29607916c6b558403d3c9
-  data.tar.gz: 80eb01f4d6aa450203c6db05a33f48bc515dc8e9a71b8532cead71439dabb373455b6cfa78c718e96364a3d7562027c6dd878a2393bca50fc9a614825c2e7a8d
+  metadata.gz: 9a0334a2851a5b2742bab2ed51b6583e8ff47c9a89c605dfd10d84f0a20a6f17a16ba59179c53bf89b1dd0ed40673fb3909966c7476410d8ee1a52e580ec5766
+  data.tar.gz: a6f1f6db5d115e7e535ec0305d62970480f7b831eb8026e940011db2fcb3576244084fbf121f1ec499c61853d03dac3a76034dd7bdd3c187b778795ce0a3b5fd

data/Gemfile

@@ -1,7 +1,7 @@
 source "https://rubygems.org"
 
-ruby '> 1.8'
+ruby "~>2.4"
 
 gemspec
 
-gem "pry", "~> 0.11.3"
+gem "pry", "~> 0.12.2"

data/README.md

@@ -8,11 +8,9 @@
 require "assert"
 
 class MyTests < Assert::Context
-
   test "something" do
-    assert_equal 1, 1
+    assert_that(1).equals(1)
   end
-
 end
 ```
 
@@ -35,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
 
@@ -52,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)
@@ -73,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)
 
-myobj.mymeth
-  # => "meth"
-myobj.myval(123)
+# OR blanket unstub all stubs
+Assert.unstub!
+
+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
@@ -413,13 +440,11 @@ If you just want to disable this feature completely:
 
 ```ruby
 Assert.configure do |config|
-
   # run nothing if the `-c` flag is given
   config.changed_proc Proc.new{ |config, test_paths| [] }
 
   # run all test paths if the `-c` flag is given
   config.changed_proc Proc.new{ |config, test_paths| test_paths }
-
 end
 ```
 
@@ -642,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,9 +18,8 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.required_ruby_version = '> 1.8'
+  gem.required_ruby_version = "~> 2.5"
 
   gem.add_dependency("much-factory", ["~> 0.1.0"])
-  gem.add_dependency("much-stub",    ["~> 0.1.0"])
-
+  gem.add_dependency("much-stub",    ["~> 0.1.4"])
 end

data/lib/assert.rb

@@ -9,7 +9,6 @@ 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
 
@@ -21,14 +20,5 @@ module Assert
   class Context
     teardown{ Assert.unstub! }
   end
-
 end
 
-# Kernel#caller_locations polyfill for pre ruby 2.0.0
-if RUBY_VERSION =~ /\A1\..+/ && !Kernel.respond_to?(:caller_locations)
-  module Kernel
-    def caller_locations(start = 1, length = nil)
-      length ? caller[start, length] : caller[start..-1]
-    end
-  end
-end

data/lib/assert/actual_value.rb

@@ -0,0 +1,127 @@
+require "much-stub"
+
+module Assert; end
+class Assert::ActualValue
+  def initialize(value, context:)
+    @value = value
+    @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 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
+
+  def is_not_the_same_as(expected_object, *args)
+    @context.assert_not_same(expected_object, @value, *args)
+  end
+
+  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,7 +1,6 @@
 require "assert/cli"
 
 module Assert
-
   class AssertRunner
     USER_SETTINGS_FILE  = ".assert/init.rb"
     LOCAL_SETTINGS_FILE = ".assert.rb"
@@ -117,7 +116,5 @@ module Assert
     end
 
     def segment_regex(seg); /^#{seg}$|^#{seg}\/|\/#{seg}\/|\/#{seg}$/; end
-
   end
-
 end

data/lib/assert/assertions.rb

@@ -1,8 +1,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." }
@@ -27,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)
@@ -42,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)
@@ -246,24 +253,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__
@@ -328,7 +317,5 @@ module Assert
         super("exception not expected, but raised:")
       end
     end
-
   end
-
 end

data/lib/assert/cli.rb

@@ -4,9 +4,7 @@ require "assert/assert_runner"
 require "assert/version"
 
 module Assert
-
   class CLI
-
     def self.debug?(args)
       args.include?("-d") || args.include?("--debug")
     end
@@ -36,40 +34,29 @@ module Assert
     def initialize(*args)
       @args = args
       @cli = CLIRB.new do
-        option "runner_seed", "use a given seed to run tests", {
-          :abbrev => "s", :value => Fixnum
-        }
-        option "changed_only", "only run test files with changes", {
-          :abbrev => "c"
-        }
-        option "changed_ref", "reference for changes, use with `-c` opt", {
-          :abbrev => "r", :value => ""
-        }
-        option "single_test", "only run the test on the given file/line", {
-          :abbrev => "t", :value => ""
-        }
-        option "pp_objects", "pretty-print objects in fail messages", {
-          :abbrev => "p"
-        }
-        option "capture_output", "capture stdout and display in result details", {
-          :abbrev => "o"
-        }
-        option "halt_on_fail", "halt a test when it fails", {
-          :abbrev => "h"
-        }
-        option "profile", "output test profile info", {
-          :abbrev => "e"
-        }
-        option "verbose", "output verbose runtime test info", {
-          :abbrev => "v"
-        }
-        option "list", "list test files on $stdout", {
-          :abbrev => "l"
-        }
+        option "runner_seed", "use a given seed to run tests",
+               abbrev: "s", value: Integer
+        option "changed_only", "only run test files with changes",
+               abbrev: "c"
+        option "changed_ref", "reference for changes, use with `-c` opt",
+               abbrev: "r", value: ""
+        option "single_test", "only run the test on the given file/line",
+               abbrev: "t", value: ""
+        option "pp_objects", "pretty-print objects in fail messages",
+               abbrev: "p"
+        option "capture_output", "capture stdout and display in result details",
+               abbrev: "o"
+        option "halt_on_fail", "halt a test when it fails",
+               abbrev: "h"
+        option "profile", "output test profile info",
+               abbrev: "e"
+        option "verbose", "output verbose runtime test info",
+               abbrev: "v"
+        option "list", "list test files on $stdout",
+               abbrev: "l"
+
         # show loaded test files, cli err backtraces, etc
-        option "debug", "run in debug mode", {
-          :abbrev => "d"
-        }
+        option "debug", "run in debug mode", abbrev: "d"
       end
     end
 
@@ -100,7 +87,6 @@ module Assert
       "Options:"\
       "#{@cli}"
     end
-
   end
 
   module RoundedMillisecondTime
@@ -111,7 +97,7 @@ module Assert
     end
   end
 
-  class CLIRB  # Version 1.0.0, https://github.com/redding/cli.rb
+  class CLIRB  # Version 1.1.0, https://github.com/redding/cli.rb
     Error    = Class.new(RuntimeError);
     HelpExit = Class.new(RuntimeError); VersionExit = Class.new(RuntimeError)
     attr_reader :argv, :args, :opts, :data
@@ -143,27 +129,25 @@ module Assert
     class Option
       attr_reader :name, :opt_name, :desc, :abbrev, :value, :klass, :parser_args
 
-      def initialize(name, *args)
-        settings, @desc = args.last.kind_of?(::Hash) ? args.pop : {}, args.pop || ""
-        @name, @opt_name, @abbrev = parse_name_values(name, settings[:abbrev])
-        @value, @klass = gvalinfo(settings[:value])
+      def initialize(name, desc = nil, abbrev: nil, value: nil)
+        @name, @desc = name, desc || ""
+        @opt_name, @abbrev = parse_name_values(name, abbrev)
+        @value, @klass = gvalinfo(value)
         @parser_args = if [TrueClass, FalseClass, NilClass].include?(@klass)
           ["-#{@abbrev}", "--[no-]#{@opt_name}", @desc]
         else
-          ["-#{@abbrev}", "--#{@opt_name} #{@opt_name.upcase}", @klass, @desc]
+          ["-#{@abbrev}", "--#{@opt_name} VALUE", @klass, @desc]
         end
       end
 
       private
 
       def parse_name_values(name, custom_abbrev)
-        [ (processed_name = name.to_s.strip.downcase), processed_name.gsub("_", "-"),
+        [ (processed_name = name.to_s.strip.downcase).gsub("_", "-"),
           custom_abbrev || processed_name.gsub(/[^a-z]/, "").chars.first || "a"
         ]
       end
-      def gvalinfo(v); v.kind_of?(Class) ? [nil,gklass(v)] : [v,gklass(v.class)]; end
-      def gklass(k); k == Fixnum ? Integer : k; end
+      def gvalinfo(v); v.kind_of?(Class) ? [nil,v] : [v,v.class]; end
     end
   end
-
 end