assert 2.16.5 → 2.18.3

checksums.yaml

@@ -1,7 +1,7 @@
---- 
-SHA1: 
-  data.tar.gz: 624cea8dff7a65ada7c133ccf0ad93d8f70fb050
-  metadata.gz: f60b216b9827bab390bb1be74d2161392a087489
-SHA512: 
-  data.tar.gz: 7dda4ee76847adaeb2b3044e186baa73c36c1f1f52c8575fa5afb73366636a86ef84381f9db39049e728881981add634206deb1fb9f1ba97932cecb0aa141f75
-  metadata.gz: 13e4b4811041f08d2686edad2f41654f6d711fdb9ed7f6d2863f7a090397ec8b7e9f460cfb6d1aba55f04cfe149992b5a44d57744f98fda4c001bd6223e7dea5
+---
+SHA256:
+  metadata.gz: ff0d6ff9233adc09dda972e165c47c125e158e46b0329b927eb7de201ddebf65
+  data.tar.gz: 8f77b5326cf44e2ed0c7ed72cac390a7147191634354feb2b890f73d572b366f
+SHA512:
+  metadata.gz: 25b58fd65c099c0c9f8ff16a652e28d5baeae76838b640872224abd7d063759d6fd40b3ec927220260d82321f78cc4b7617d50a081c7ba336b04d45acec8f618
+  data.tar.gz: 669749ff845ae1811802042dd28e27e7a387d9d39a9504d73b8b04667c9597c4da08bd56cc26a7b34838e5afde2970215027a7d3967ad1e7f99175c62c49a08e

data/Gemfile

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

data/README.md

@@ -5,14 +5,12 @@
 ```ruby
 # in test/my_tests.rb
 
-require 'assert'
+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,64 +72,92 @@ 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
-  # => 'stub-meth'
-myobj.mymeth(123)
+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"
+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)
-  # => '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(123)
+  # => "123"
+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
 
 ```ruby
-require 'assert/factory'
+require "assert/factory"
 
 Assert::Factory.integer    #=> 15742
 Assert::Factory.integer(3) #=> 2
@@ -197,7 +224,7 @@ As an example, say your test folder has a file structure like so:
 |  |  - slow_tests.rb
 ```
 
-* `$ assert` - runs all tests ('./test' is used if no paths are given)
+* `$ assert` - runs all tests ("./test" is used if no paths are given)
 * `$ assert test/basic` - run all tests in basic_tests.rb
 * `$ assert test/complex/fast_tests.rb` - runs all tests in fast_tests.rb
 * `$ assert test/basic test/comp` - runs all tests in basic_tests.rb, complex_tests.rb, fast_tests.rb and slow_tests.rb
@@ -237,7 +264,7 @@ Assert accepts options from its CLI.  Use these options to specify absolute runt
 Assert uses its [`Assert::Runner`](/lib/assert/runner.rb) to run tests.  You can extend this default runner or use your own runner implementation.  Specify it in your user/local settings:
 
 ```ruby
-require 'my_awesome_runner_class'
+require "my_awesome_runner_class"
 
 Assert.configure do |config|
   config.runner MyAwesomeRunnerClass.new
@@ -326,7 +353,7 @@ $ assert [-v|--verbose|--no-verbose]
 
 ### Capture Output
 
-By default, Assert shows any output on `$stdout` produced while running a test.  It provides a setting to override whether to show this output or to 'capture' it and display it in the test result details:
+By default, Assert shows any output on `$stdout` produced while running a test.  It provides a setting to override whether to show this output or to "capture" it and display it in the test result details:
 
 In user/local settings file:
 
@@ -404,7 +431,7 @@ This, of course, assumes you are working in a git repository.  If you are not or
 ```ruby
 Assert.configure do |config|
   config.changed_proc Proc.new do |config, test_paths|
-    `git diff --name-only master -- #{test_paths.join(' ')}`.split("\n")  # or whatever
+    `git diff --name-only master -- #{test_paths.join(" ")}`.split("\n")  # or whatever
   end
 end
 ```
@@ -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
 ```
 
@@ -571,7 +596,7 @@ Beyond that, each view can do as it sees fit.  Initialize how you wish, take wha
 To use a 3rd party custom view, first require it in and then configure it.  Assert provides a helper for requiring in views.  It can be used in two ways.  You can pass a fully qualified path to the helper and if it exists, will require it in.
 
 ```ruby
-Assert::View.require_user_view '/path/to/my/view'
+Assert::View.require_user_view "/path/to/my/view"
 ```
 
 Alternatively, you can install/clone/copy/write your view implementations in `~/.assert/views` and require it in by name.  To have assert require it by name, have it installed at `~/assert/views/view_name/lib/view_name.rb` (this structure is compatible with popular conventions for rubygem development). For example:
@@ -579,7 +604,7 @@ Alternatively, you can install/clone/copy/write your view implementations in `~/
 ```ruby
 # assuming ~/.assert/views/my-custom-view/lib/my-custom-view.rb exists
 # this will require it in
-Assert::View.require_user_view 'my-custom-view'
+Assert::View.require_user_view "my-custom-view"
 ```
 
 Once your view class is required in, use it and configure it just as you would any view.
@@ -592,7 +617,7 @@ A `Suite` object is reponsible for collecting and structuring tests and defines
 
 ### Runner
 
-A `Runner` object is responsible for running a suite of tests and firing event callbacks to the `View`.  Any runner object should take the test suite and view as arguments and should provide a 'run' method that runs the tests and renders the view.
+A `Runner` object is responsible for running a suite of tests and firing event callbacks to the `View`.  Any runner object should take the test suite and view as arguments and should provide a "run" method that runs the tests and renders the view.
 
 ### Context
 
@@ -620,7 +645,7 @@ A `View` object is responsible for rendering test result output.  Assert provide
 
 ### Macro
 
-Macros are procs that define sets of test code and make it available for easy reuse.  Macros work nicely with the 'should' and 'test' context methods.
+Macros are procs that define sets of test code and make it available for easy reuse.  Macros work nicely with the "should" and "test" context methods.
 
 ## Installation
 
@@ -636,10 +661,10 @@ If submitting a Pull Request, please:
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
+3. Commit your changes (`git commit -am "Added some feature"`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
 
 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,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "assert/version"
 
@@ -11,14 +11,15 @@ Gem::Specification.new do |gem|
   gem.summary     = %q{Assertion style testing framework.}
   gem.description = %q{Assertion style testing framework.}
   gem.homepage    = "http://github.com/redding/assert"
-  gem.license     = 'MIT'
+  gem.license     = "MIT"
 
-  gem.files         = `git ls-files`.split($/)
+  gem.files         = `git ls-files | grep "^[^.]"`.split($/)
   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.add_dependency("much-factory", ["~> 0.1.0"])
-  gem.add_dependency("much-stub",    ["~> 0.1.0"])
+  gem.required_ruby_version = "~> 2.5"
 
+  gem.add_dependency("much-factory", ["~> 0.1.0"])
+  gem.add_dependency("much-stub",    ["~> 0.1.4"])
 end

data/bin/assert

@@ -3,10 +3,10 @@
 # Copyright (c) 2011-Present Kelly Redding and Collin Redding
 #
 
-require 'assert'
-require 'assert/cli'
+require "assert"
+require "assert/cli"
 
-Assert.config.debug ENV['ASSERT_DEBUG'] == 'true' || Assert::CLI.debug?(ARGV)
+Assert.config.debug ENV["ASSERT_DEBUG"] == "true" || Assert::CLI.debug?(ARGV)
 
-Assert::CLI.bench('CLI init and parse'){ @cli = Assert::CLI.new(*ARGV) }
+Assert::CLI.bench("CLI init and parse"){ @cli = Assert::CLI.new(*ARGV) }
 @cli.run

data/lib/assert.rb

@@ -1,15 +1,14 @@
-require 'assert/version'
+require "assert/version"
 
-require 'assert/config'
-require 'assert/context'
-require 'assert/runner'
-require 'assert/stub'
-require 'assert/suite'
-require 'assert/utils'
-require 'assert/view'
+require "assert/config"
+require "assert/context"
+require "assert/runner"
+require "assert/stub"
+require "assert/suite"
+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