assert 2.18.2 → 2.18.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93616ac8a1849d9f356088b0386907f946cf89465e84aaa6321ceff60f7012de
-  data.tar.gz: a4436d1c9d437cb56343318885b1a32d804ad2e71c956408cd877d695f3d9675
+  metadata.gz: ff0d6ff9233adc09dda972e165c47c125e158e46b0329b927eb7de201ddebf65
+  data.tar.gz: 8f77b5326cf44e2ed0c7ed72cac390a7147191634354feb2b890f73d572b366f
 SHA512:
-  metadata.gz: 424110cb0d83c44fcdc66129532bc53859a74a0b2f63f2b08081955d6aee813a9df11f37afbdc325f464866ca0263fc98164992d08949fa2573410f9056334c6
-  data.tar.gz: 25b2980b91b9e4dddf9724f64cbdc81214c910008157f0ac88f3e3a1c6f4ae8162065d08ef4a2c2eb78ff2211cdc49fdac893397e50e04b5816174eb8293c01b
+  metadata.gz: 25b58fd65c099c0c9f8ff16a652e28d5baeae76838b640872224abd7d063759d6fd40b3ec927220260d82321f78cc4b7617d50a081c7ba336b04d45acec8f618
+  data.tar.gz: 669749ff845ae1811802042dd28e27e7a387d9d39a9504d73b8b04667c9597c4da08bd56cc26a7b34838e5afde2970215027a7d3967ad1e7f99175c62c49a08e

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

@@ -21,5 +21,5 @@ 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-stub",    ["~> 0.1.4"])
 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/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)
@@ -244,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__

data/lib/assert/context.rb

@@ -1,4 +1,7 @@
+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"
@@ -16,6 +19,8 @@ module Assert
     extend SubjectDSL
     extend SuiteDSL
     extend TestDSL
+    extend LetDSL
+    include MethodMissing
     include Assert::Assertions
     include Assert::Macros::Methods
 
@@ -61,9 +66,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 +82,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,6 +92,10 @@ module Assert
     end
     alias_method :refute, :assert_not
 
+    def assert_that(actual_value)
+      Assert::ActualValue.new(actual_value, context: self)
+    end
+
     # adds a Pass result to the end of the test's results
     # does not break test execution
     def pass(pass_msg = nil)

data/lib/assert/context/let_dsl.rb

@@ -0,0 +1,13 @@
+module Assert; end
+class Assert::Context; end
+module Assert::Context::LetDSL
+  def let(name, &block)
+    self.send(:define_method, name, &-> {
+      if instance_variable_get("@#{name}").nil?
+        instance_variable_set("@#{name}", instance_eval(&block))
+      end
+
+      instance_variable_get("@#{name}")
+    })
+  end
+end

data/lib/assert/context/method_missing.rb

@@ -0,0 +1,19 @@
+require "assert/assertions"
+
+module Assert; end
+class Assert::Context; end
+module Assert::Context::MethodMissing
+  def method_missing(method, *args, &block)
+    if Assert::Assertions::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
+
+  def respond_to_missing?(method, *)
+    Assert::Assertions::IGNORED_ASSERTION_HELPERS.include?(method.to_sym) ||
+    super
+  end
+end

data/lib/assert/macros/methods.rb

@@ -102,28 +102,28 @@ module Assert::Macros
           self.class._methods_macro_instance_methods.each do |(method, called_from)|
             msg = "#{subject.class.name} does not have instance method ##{method}"
             with_backtrace([called_from]) do
-              assert_respond_to method, subject, msg
+              assert_that(subject).responds_to(method, msg)
             end
           end
 
           self.class._methods_macro_class_methods.each do |(method, called_from)|
             msg = "#{subject.class.name} does not have class method ##{method}"
             with_backtrace([called_from]) do
-              assert_respond_to method, subject.class, msg
+              assert_that(subject.class).responds_to(method, msg)
             end
           end
 
           self.class._methods_macro_not_instance_methods.each do |(method, called_from)|
             msg = "#{subject.class.name} has instance method ##{method}"
             with_backtrace([called_from]) do
-              assert_not_respond_to method, subject, msg
+              assert_that(subject).does_not_respond_to(method, msg)
             end
           end
 
           self.class._methods_macro_not_class_methods.each do |(method, called_from)|
             msg = "#{subject.class.name} has class method ##{method}"
             with_backtrace([called_from]) do
-              assert_not_respond_to method, subject.class, msg
+              assert_that(subject.class).does_not_respond_to(method, msg)
             end
           end
         end

data/lib/assert/stub.rb

@@ -9,6 +9,10 @@ module Assert
     MuchStub.stub(*args, &block)
   end
 
+  def self.stub_on_call(*args, &block)
+    MuchStub.stub_on_call(*args, &block)
+  end
+
   def self.unstub(*args)
     MuchStub.unstub(*args)
   end

data/lib/assert/version.rb

@@ -1,3 +1,3 @@
 module Assert
-  VERSION = "2.18.2"
+  VERSION = "2.18.3"
 end

data/test/helper.rb

@@ -9,38 +9,36 @@ $LOAD_PATH.unshift(ROOT_PATH)
 require "pry"
 require "test/support/factory"
 
-class Assert::Test
-  module TestHelpers
-    def self.included(receiver)
-      receiver.class_eval do
-        setup do
-          @test_run_results = []
-          @run_callback = proc{ |result| @test_run_results << result }
-        end
+module Assert::Test::TestHelpers
+  def self.included(receiver)
+    receiver.class_eval do
+      setup do
+        @test_run_results = []
+        @run_callback = proc { |result| @test_run_results << result }
       end
+    end
 
-      private
+    private
 
-      def test_run_callback
-        @run_callback
-      end
+    def test_run_callback
+      @run_callback
+    end
 
-      def test_run_results(type = nil)
-        return @test_run_results if type.nil?
-        @test_run_results.select{ |r| r.type == type }
-      end
+    def test_run_results(type = nil)
+      return @test_run_results if type.nil?
+      @test_run_results.select{ |r| r.type == type }
+    end
 
-      def test_run_result_count(type = nil)
-        test_run_results(type).count
-      end
+    def test_run_result_count(type = nil)
+      test_run_results(type).count
+    end
 
-      def test_run_result_messages
-        @test_run_results.map(&:message)
-      end
+    def test_run_result_messages
+      @test_run_results.map(&:message)
+    end
 
-      def last_test_run_result
-        @test_run_results.last
-      end
+    def last_test_run_result
+      @test_run_results.last
     end
   end
 end

data/test/support/factory.rb

@@ -85,4 +85,19 @@ module Factory
       instance_eval(&block) if !block.nil?
     end
   end
+
+  def self.modes_off_context(&result_block)
+    test = Factory.test
+    Factory.modes_off_context_class.new(
+      test,
+      test.config,
+      result_block || proc { |r| }
+    )
+  end
+
+  def self.backtrace
+    assert_lib_path =
+      File.join(ROOT_PATH, "lib/#{Factory.string}:#{Factory.integer}")
+    (Factory.integer(3).times.map{ Factory.string } + [assert_lib_path]).shuffle
+  end
 end