spectus 3.0.10 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13481b61d71af90cd7460d98c76eb3e13914e2720f7364433a746571d78e63d6
-  data.tar.gz: 71843f9b4ad356df5a992494978a2275dcccafb207eebcc5067e21d04a1438c4
+  metadata.gz: 61974cb7f8cc0f5e3feaab04f902099123a2f71fa815af3d5d5230b49a8dc573
+  data.tar.gz: bd85d771520589ee1a10ff672f610e04ad00bdb254343241f7aacc32a1af8f5a
 SHA512:
-  metadata.gz: 538622c03f5c9e52cda46b1c76b7c7d80ffad22e18abb6bc56a52ad371bdacb4ed292b9b6a44c29894ac1ca2ea319e22c053a448baa32aedf28ec143fa8cba11
-  data.tar.gz: 638c15fc458db6ee8cc4381b16235df22ed8c6020f56b9d79f8330f28f32af34d9a50684b8b87e43ed83bac10c7c2822a8ef98cb03407ed2edae5d584312ebbd
+  metadata.gz: baf4571bbc6b585b87b6d98752bf4ba1880c99fb05bfbb1d66d0587aadc8ec9fb3481cacb5bd8f193a53eca5269002a92d1a9900ee7e9ad8874e5950a7b5dd8a
+  data.tar.gz: b0819b033292607bc53ba1c690f09dad9c95566e70e102f02cde1a9b0c6e42d6b58db1dd16d5ece1423e8bef94841c3d9b37775d2f08e205e2a054df079ad97e

data/README.md

@@ -1,24 +1,12 @@
 # Spectus
 
-[![Build Status](https://travis-ci.org/fixrb/spectus.svg?branch=master)][travis]
+[![Build Status](https://api.travis-ci.org/fixrb/spectus.svg?branch=master)][travis]
 [![Code Climate](https://codeclimate.com/github/fixrb/spectus/badges/gpa.svg)][codeclimate]
 [![Gem Version](https://badge.fury.io/rb/spectus.svg)][gem]
-[![Inline docs](http://inch-ci.org/github/fixrb/spectus.svg?branch=master)][inchpages]
-[![Documentation](http://img.shields.io/:yard-docs-38c800.svg)][rubydoc]
+[![Inline docs](https://inch-ci.org/github/fixrb/spectus.svg?branch=master)][inchpages]
+[![Documentation](https://img.shields.io/:yard-docs-38c800.svg)][rubydoc]
 
-> Expectation library with [RFC 2119](https://www.ietf.org/rfc/rfc2119.txt)'s requirement levels, and some matchers for Ruby.
-
-## Contact
-
-* Home page: https://github.com/fixrb/spectus
-* Bugs/issues: https://github.com/fixrb/spectus/issues
-* Support: https://stackoverflow.com/questions/tagged/spectus
-
-## Rubies
-
-* [MRI](https://www.ruby-lang.org/)
-* [Rubinius](http://rubini.us/)
-* [JRuby](http://jruby.org/)
+> Expectation library with [RFC 2119](https://www.ietf.org/rfc/rfc2119.txt)'s requirement levels 🚥
 
 ## Installation
 
@@ -40,6 +28,8 @@ Or install it yourself as:
 
 An expectation is an assertion that is either `true` or `false`.
 
+There are several scenarios:
+
 | Requirement levels        | **MUST** | **SHOULD** | **MAY** |
 | ------------------------- | -------- | ---------- | ------- |
 | Implemented & Matched     | `true`   | `true`     | `true`  |
@@ -47,39 +37,43 @@ An expectation is an assertion that is either `true` or `false`.
 | Implemented & Exception   | `false`  | `false`    | `false` |
 | Not implemented           | `false`  | `false`    | `true`  |
 
-## Isolation
+Thus,
 
-There are two cases:
+* when an expectation is `true`, a `Spectus::Result::Pass` instance is returned;
+* when an expectation is `false`, a `Spectus::Result::Fail` exception is raised.
 
-* when the requirement level of an expectation ends with `!`, the test is performed in isolation;
-* when the requirement level of an expectation does not end with `!`, the test is performed without isolation.
+Both results share a common interface, and can be classified respectively as:
 
-Example of test in isolation:
+* a ✅ _success_, a ⚠️ _warning_ or an 💡 _info_;
+* a ❌ _failure_ or an 💥 _error_.
 
-```ruby
-greeting = 'Hello, world!'
-it { greeting.gsub!('world', 'Alice') }.MUST! eql 'Hello, Alice!'
-# => #<Spectus::Result::Pass:0x007fa5022d8760 @message="Pass: Expected \"Hello, Alice!\" to eql \"Hello, Alice!\".", @subject=#<Proc:0x007fa5022d8e18@(irb):3>, @challenge=#<Defi::Challenge:0x007fa5022d8a08 @method=:call, @args=[]>, @actual="Hello, Alice!", @expected=#<Matchi::Eql:0x007fa5022d8cb0 @expected="Hello, Alice!">, @got=true, @error=nil, @level=:High, @negate=false, @valid=true>
-greeting # => "Hello, world!"
-```
+## Code Isolation
+
+When executing expectations, side-effects may occur.
+Because they may or may not be desired, each requirement level has 2 versions:
+
+* if it does not end with `!`, its test is performed without isolation;
+* if it ends with `!`, its test is performed in isolation.
 
 Example of test without isolation:
 
 ```ruby
+include Spectus
 greeting = 'Hello, world!'
 it { greeting.gsub!('world', 'Alice') }.MUST eql 'Hello, Alice!'
-# => #<Spectus::Result::Pass:0x007f982304d310 @message="Pass: Expected \"Hello, Alice!\" to eql \"Hello, Alice!\".", @subject=#<Proc:0x007f982304fbb0@(irb):3>, @challenge=#<Defi::Challenge:0x007f982304f890 @method=:call, @args=[]>, @actual="Hello, Alice!", @expected=#<Matchi::Eql:0x007f982304f200 @expected="Hello, Alice!">, @got=true, @error=nil, @level=:High, @negate=false, @valid=true>
+# => Spectus::Result::Pass(actual: "Hello, Alice!", error: nil, expected: "Hello, Alice!", got: true, matcher: :eql, negate: false, level: :MUST, valid: true)
 greeting # => "Hello, Alice!"
 ```
 
-## Results
-
-There are two cases:
-
-* when an expectation is `true`, an instance of `Spectus::Result::Pass` is returned;
-* when an expectation is `false`, an instance of `Spectus::Result::Fail` is raised.
+Example of test in isolation:
 
-Both instances share the same interface.
+```ruby
+include Spectus
+greeting = 'Hello, world!'
+it { greeting.gsub!('world', 'Alice') }.MUST! eql 'Hello, Alice!'
+# => Spectus::Result::Pass(actual: "Hello, Alice!", error: nil, expected: "Hello, Alice!", got: true, matcher: :eql, negate: false, level: :MUST, valid: true)
+greeting # => "Hello, world!"
+```
 
 ## Usage
 
@@ -89,24 +83,24 @@ To begin with, let's include __Spectus__:
 include Spectus
 ```
 
-### Absolute requirement
+### Absolute Requirement
 
-Given the `"ルビー"` object, when it receives `valid_encoding?` method, then it **MUST** be `true`:
+Given the "`ルビー`" object, when it receives `valid_encoding?` method, then it **MUST** be `true`:
 
 ```ruby
 it { 'ルビー'.valid_encoding? }.MUST be_true
-# => #<Spectus::Result::Pass:0x007ffd7d00af50 @message="Pass: Expected true to be_true.", @subject=#<Proc:0x007ffd7d010130@(irb):2>, @challenge=#<Defi::Challenge:0x007ffd7d0116e8 @method=:call, @args=[]>, @actual=true, @expected=#<Matchi::BeTrue:0x007ffd7d012188>, @got=true, @error=nil, @level=:High, @negate=false, @valid=true>
+# => Spectus::Result::Pass(actual: true, error: nil, expected: nil, got: true, matcher: :be_true, negate: false, level: :MUST, valid: true)
 ```
 
 The result of the test shows that the spec passed.
 
-### Absolute prohibition
+### Absolute Prohibition
 
-Given the `"foo"` object, when it receives `length` method, then it **MUST NOT** raise the `NoMethodError` exception:
+Given the "`foo`" object, when it receives `length` method, then it **MUST NOT** raise the `NoMethodError` exception:
 
 ```ruby
 it { 'foo'.length }.MUST_NOT raise_exception NoMethodError
-# => #<Spectus::Result::Pass:0x007ffd7b890af0 @message="Pass: Expected 3 not to raise_exception NoMethodError.", @subject=#<Proc:0x007ffd7b8913b0@(irb):3>, @challenge=#<Defi::Challenge:0x007ffd7b891248 @method=:call, @args=[]>, @actual=3, @expected=#<Matchi::RaiseException:0x007ffd7b891130 @expected=NoMethodError>, @got=true, @error=nil, @level=:High, @negate=true, @valid=true>
+# => Spectus::Result::Pass(actual: 3, error: nil, expected: NoMethodError, got: true, matcher: :raise_exception, negate: true, level: :MUST, valid: true)
 ```
 
 The result of the test shows that the spec passed.
@@ -117,74 +111,69 @@ Given the `BasicObject` object, when it receives `superclass` method, then it **
 
 ```ruby
 it { BasicObject.superclass }.SHOULD equal NilClass
-# => #<Spectus::Result::Pass:0x007ffd7b871a38 @message="Info: Expected nil to equal NilClass.", @subject=#<Proc:0x007ffd7b872460@(irb):4>, @challenge=#<Defi::Challenge:0x007ffd7b872370 @method=:call, @args=[]>, @actual=nil, @expected=#<Matchi::Equal:0x007ffd7b872140 @expected=NilClass>, @got=false, @error=nil, @level=:Medium, @negate=false, @valid=false>
+# => Spectus::Result::Pass(actual: nil, error: nil, expected: NilClass, got: false, matcher: :equal, negate: false, level: :SHOULD, valid: false)
 ```
 
 Instead of the expected `NilClass` class, its sole instance (which is `nil`) was returned.
 However, because there isn't any exception, the result of the test shows that the spec passed.
 
-### Not recommended
+### Not Recommended
 
-Given the `"1"` object, when it receives `+(1)` method, then it **SHOULD NOT** return the `"11"` value:
+Given the "`1`" object, when it receives `+(1)` method, then it **SHOULD NOT** return the "`11`" value:
 
 ```ruby
 it { '1' + 1 }.SHOULD_NOT eql '11'
-# Spectus::Result::Fail: Error: no implicit conversion of Fixnum into String (TypeError).
-# 	from (irb):5
-# 	from ./bin/console:7:in `<main>'
+# raise Spectus::Result::Fail(actual: nil, error: #<TypeError: no implicit conversion of Integer into String>, expected: "11", got: nil, matcher: :eql, negate: true, level: :SHOULD, valid: false)
 ```
 
 There was a `TypeError` exception, the result of the test shows that the spec failed.
 
 ### Optional
 
-Given the `"foo"` object, when it receives `blank?` method, then it **MAY** be `false`:
+Given the "`foo`" object, when it receives `blank?` method, then it **MAY** be `false`:
 
 ```ruby
 it { 'foo'.blank? }.MAY be_false
-# => #<Spectus::Result::Pass:0x007ffd7bbc3cb8 @message="Info: undefined method `blank?' for \"foo\":String (NoMethodError).", @subject=#<Proc:0x007ffd7b8285b8@(irb):6>, @challenge=#<Defi::Challenge:0x007ffd7b8284f0 @method=:call, @args=[]>, @actual=nil, @expected=#<Matchi::BeFalse:0x007ffd7b828310>, @got=nil, @error=#<NoMethodError: undefined method `blank?' for "foo":String>, @level=:Low, @negate=false, @valid=false>
+# => Spectus::Result::Pass(actual: nil, error: #<NoMethodError: undefined method `blank?' for "foo":String>, expected: nil, got: nil, matcher: :be_false, negate: false, level: :MAY, valid: false)
 ```
 
-The optional `blank?` method is not implemented (unlike in [Ruby on Rails](http://api.rubyonrails.org/classes/Object.html#method-i-blank-3F), for instance), so the result of the test shows that the spec passed.
+The optional `blank?` method is not implemented (unlike in [Ruby on Rails](https://api.rubyonrails.org/classes/Object.html#method-i-blank-3F), for instance), so the result of the test shows that the spec passed.
 
-## Security
+### More Examples
 
-As a basic form of security __Spectus__ provides a set of SHA512 checksums for
-every Gem release.  These checksums can be found in the `checksum/` directory.
-Although these checksums do not prevent malicious users from tampering with a
-built Gem they can be used for basic integrity verification purposes.
+An exhaustive list of examples can also be viewed here:
+[test.rb](https://github.com/fixrb/spectus/raw/master/test.rb)
 
-The checksum of a file can be checked using the `sha512sum` command.  For
-example:
+## Contact
 
-    $ sha512sum pkg/spectus-2.3.0.gem
-    e9e35e1953104e2d428b0f217e418db3c1baecd9e011b2545f9fcba4ff7e3bba674c6b928b3d8db842a139cd7cc9806d77ebdc7f710ece4f2aecb343703e2451  pkg/spectus-2.3.0.gem
+* Home page: https://github.com/fixrb/spectus
+* Bugs/issues: https://github.com/fixrb/spectus/issues
 
-## Versioning
+## Rubies
 
-__Spectus__ follows [Semantic Versioning 2.0](http://semver.org/).
+* [MRI](https://www.ruby-lang.org/)
+* [Rubinius](https://rubinius.com/)
+* [JRuby](https://www.jruby.org/)
 
-## Contributing
+## Versioning
 
-1. [Fork it](https://github.com/fixrb/spectus/fork)
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+__Spectus__ follows [Semantic Versioning 2.0](https://semver.org/).
 
 ## License
 
-See `LICENSE.md` file.
-
-[gem]: https://rubygems.org/gems/spectus
-[travis]: https://travis-ci.org/fixrb/spectus
-[codeclimate]: https://codeclimate.com/github/fixrb/spectus
-[gemnasium]: https://gemnasium.com/fixrb/spectus
-[inchpages]: http://inch-ci.org/github/fixrb/spectus
-[rubydoc]: http://rubydoc.info/gems/spectus/frames
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
 ***
 
-This project is sponsored by:
+<p>
+  This project is sponsored by:<br />
+  <a href="https://sashite.com/"><img
+    src="https://github.com/fixrb/spectus/raw/master/img/sashite.png"
+    alt="Sashite" /></a>
+</p>
 
-[![Sashite](https://pbs.twimg.com/profile_images/618485028322975744/PZ9qPuI__400x400.png)](https://sashite.com/)
+[gem]: https://rubygems.org/gems/spectus
+[travis]: https://travis-ci.org/fixrb/spectus
+[codeclimate]: https://codeclimate.com/github/fixrb/spectus
+[inchpages]: https://inch-ci.org/github/fixrb/spectus
+[rubydoc]: https://rubydoc.info/gems/spectus/frames

data/lib/spectus.rb

@@ -1,16 +1,14 @@
 # frozen_string_literal: true
 
-require_relative File.join('spectus', 'matchers')
+require 'matchi/helper'
 
 # Namespace for the Spectus library.
 #
-# @api public
-#
 # @example It MUST equal 42.
 #   require 'spectus'
 #   it { 42 }.MUST equal 42 # => #<Spectus::Result::Pass...>
 module Spectus
-  include Matchers
+  include ::Matchi::Helper
 
   # Expectations are built with this method.
   #

data/lib/spectus/exam.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'defi'
+
+module Spectus
+  # This class evaluate the expectation with the passed block.
+  class Exam
+    # Execute the untested code from the passed block against the matcher.
+    #
+    # rubocop:disable Lint/RescueException
+    #
+    # @param callable   [#call]     The callable object to test.
+    # @param isolation  [Boolean]   Compute actual in isolation?
+    # @param negate     [Boolean]   Positive or negative assertion?
+    # @param matcher    [#matches?] The matcher.
+    def initialize(callable:, isolation:, negate:, matcher:)
+      @got = negate ^ matcher.matches? do
+        value = if isolation
+                  send_call.to!(callable)
+                else
+                  send_call.to(callable)
+                end
+
+        @actual = value.object
+
+        value.call
+      end
+    rescue ::Exception => e
+      @actual     = nil
+      @exception  = e
+    end
+    # rubocop:enable Lint/RescueException
+
+    # @return [#object_id] The actual value.
+    attr_reader :actual
+
+    # @return [Exception, nil] An exception.
+    attr_reader :exception
+
+    # @return [Boolean, nil] Report to the spec requirement level if the
+    #   expectation is true or false.
+    attr_reader :got
+
+    # @return [Defi::Challenge] The challenge for the callable object.
+    def send_call
+      ::Defi.send(:call)
+    end
+
+    # Report to the spec requirement level if the test pass or fail.
+    #
+    # @return [Boolean] Report if the test pass or fail?
+    def valid?
+      exception.nil? ? got : false
+    end
+  end
+end

data/lib/spectus/expectation_target.rb

@@ -1,49 +1,49 @@
 # frozen_string_literal: true
 
-require 'defi'
-
 module Spectus
   # Wraps the target of an expectation.
   #
-  # @api public
-  #
   # @example
   #   it { actual value } # => ExpectationTarget wrapping the block
   class ExpectationTarget
-    # Create a new expection target
+    # Create a new expectation target
     #
-    # @api private
-    #
-    # @param subject [Proc] The value which is compared with the expected value.
-    def initialize(&subject)
-      @subject    = subject
-      @challenges = [block_challenge]
+    # @param callable [Proc] The object to test.
+    def initialize(&callable)
+      @callable = callable
     end
 
-    # rubocop:disable Style/MethodName
-    # rubocop:disable Naming/UncommunicativeMethodParamName
+    # rubocop:disable Naming/MethodName
 
-    # @api public
-    #
     # This word, or the terms "REQUIRED" or "SHALL", mean that the
     # definition is an absolute requirement of the specification.
     #
     # @example _Absolute requirement_ definition
     #   it { 'foo'.upcase }.MUST eql 'FOO'
     #
-    # @param m [#matches?] The matcher.
+    # @param matcher [#matches?] The matcher.
     #
     # @return [Result::Fail, Result::Pass] Report if the spec pass or fail.
-    def MUST(m)
-      RequirementLevel::High.new(m, false, subject, *challenges).result
+    def MUST(matcher)
+      RequirementLevel::Must.new(
+        callable:   callable,
+        isolation:  false,
+        negate:     false,
+        matcher:    matcher
+      ).call
     end
 
     # @example _Absolute requirement_ definition with isolation
     #   it { 'foo'.upcase }.MUST! eql 'FOO'
     #
     # @see MUST
-    def MUST!(m)
-      RequirementLevel::High.new(m, false, subject, *challenges).result(true)
+    def MUST!(matcher)
+      RequirementLevel::Must.new(
+        callable:   callable,
+        isolation:  true,
+        negate:     false,
+        matcher:    matcher
+      ).call
     end
 
     # This phrase, or the phrase "SHALL NOT", mean that the
@@ -52,19 +52,29 @@ module Spectus
     # @example _Absolute prohibition_ definition
     #   it { 'foo'.size }.MUST_NOT equal 42
     #
-    # @param m [#matches?] The matcher.
+    # @param matcher [#matches?] The matcher.
     #
     # @return [Result::Fail, Result::Pass] Report if the spec pass or fail.
-    def MUST_NOT(m)
-      RequirementLevel::High.new(m, true, subject, *challenges).result
+    def MUST_NOT(matcher)
+      RequirementLevel::Must.new(
+        callable:   callable,
+        isolation:  false,
+        negate:     true,
+        matcher:    matcher
+      ).call
     end
 
     # @example _Absolute prohibition_ definition with isolation
     #   it { 'foo'.size }.MUST_NOT! equal 42
     #
     # @see MUST_NOT
-    def MUST_NOT!(m)
-      RequirementLevel::High.new(m, true, subject, *challenges).result(true)
+    def MUST_NOT!(matcher)
+      RequirementLevel::Must.new(
+        callable:   callable,
+        isolation:  true,
+        negate:     true,
+        matcher:    matcher
+      ).call
     end
 
     # This word, or the adjective "RECOMMENDED", mean that there
@@ -75,19 +85,29 @@ module Spectus
     # @example _Recommended_ definition
     #   it { 'foo'.valid_encoding? }.SHOULD equal true
     #
-    # @param m [#matches?] The matcher.
+    # @param matcher [#matches?] The matcher.
     #
     # @return [Result::Fail, Result::Pass] Report if the spec pass or fail.
-    def SHOULD(m)
-      RequirementLevel::Medium.new(m, false, subject, *challenges).result
+    def SHOULD(matcher)
+      RequirementLevel::Should.new(
+        callable:   callable,
+        isolation:  false,
+        negate:     false,
+        matcher:    matcher
+      ).call
     end
 
     # @example _Recommended_ definition with isolation
     #   it { 'foo'.valid_encoding? }.SHOULD! equal true
     #
     # @see SHOULD
-    def SHOULD!(m)
-      RequirementLevel::Medium.new(m, false, subject, *challenges).result(true)
+    def SHOULD!(matcher)
+      RequirementLevel::Should.new(
+        callable:   callable,
+        isolation:  true,
+        negate:     false,
+        matcher:    matcher
+      ).call
     end
 
     # This phrase, or the phrase "NOT RECOMMENDED" mean that
@@ -99,19 +119,29 @@ module Spectus
     # @example _Not recommended_ definition
     #   it { ''.blank? }.SHOULD_NOT raise_exception NoMethodError
     #
-    # @param m [#matches?] The matcher.
+    # @param matcher [#matches?] The matcher.
     #
     # @return [Result::Fail, Result::Pass] Report if the spec pass or fail.
-    def SHOULD_NOT(m)
-      RequirementLevel::Medium.new(m, true, subject, *challenges).result
+    def SHOULD_NOT(matcher)
+      RequirementLevel::Should.new(
+        callable:   callable,
+        isolation:  false,
+        negate:     true,
+        matcher:    matcher
+      ).call
     end
 
     # @example _Not recommended_ definition with isolation
     #   it { ''.blank? }.SHOULD_NOT! raise_exception NoMethodError
     #
     # @see SHOULD_NOT
-    def SHOULD_NOT!(m)
-      RequirementLevel::Medium.new(m, true, subject, *challenges).result(true)
+    def SHOULD_NOT!(matcher)
+      RequirementLevel::Should.new(
+        callable:   callable,
+        isolation:  true,
+        negate:     true,
+        matcher:    matcher
+      ).call
     end
 
     # This word, or the adjective "OPTIONAL", mean that an item is
@@ -129,53 +159,40 @@ module Spectus
     # @example _Optional_ definition
     #   it { 'foo'.bar }.MAY match /^foo$/
     #
-    # @param m [#matches?] The matcher.
+    # @param matcher [#matches?] The matcher.
     #
     # @return [Result::Fail, Result::Pass] Report if the spec pass or fail.
-    def MAY(m)
-      RequirementLevel::Low.new(m, false, subject, *challenges).result
+    def MAY(matcher)
+      RequirementLevel::May.new(
+        callable:   callable,
+        isolation:  false,
+        negate:     false,
+        matcher:    matcher
+      ).call
     end
 
     # @example _Optional_ definition with isolation
     #   it { 'foo'.bar }.MAY! match /^foo$/
     #
     # @see MAY
-    def MAY!(m)
-      RequirementLevel::Low.new(m, false, subject, *challenges).result(true)
+    def MAY!(matcher)
+      RequirementLevel::May.new(
+        callable:   callable,
+        isolation:  true,
+        negate:     false,
+        matcher:    matcher
+      ).call
     end
 
-    # rubocop:enable Style/MethodName
-    # rubocop:enable Naming/UncommunicativeMethodParamName
+    # rubocop:enable Naming/MethodName
 
-    # rubocop:disable Style/AccessModifierDeclarations
+    protected
 
-    # @!attribute [r] subject
-    #
-    # @return [BasicObject] The front object to be tested.
-    attr_reader :subject
-    private :subject
-
-    # @!attribute [r] challenges
-    #
-    # @return [Array] The challenges to call on the subject.
-    attr_reader :challenges
-    private :challenges
-
-    # rubocop:enable Style/AccessModifierDeclarations
-
-    private
-
-    # The first default challenge for blocks.
-    #
-    # @since 2.10.0
-    #
-    # @return [Defi] The challenge for blocks.
-    def block_challenge
-      ::Defi.send(:call)
-    end
+    # @return [#call] The callable object to test.
+    attr_reader :callable
   end
 end
 
-require_relative File.join('requirement_level', 'high')
-require_relative File.join('requirement_level', 'medium')
-require_relative File.join('requirement_level', 'low')
+require_relative File.join('requirement_level', 'must')
+require_relative File.join('requirement_level', 'should')
+require_relative File.join('requirement_level', 'may')