spectus 2.0.3 → 2.1.0

data/lib/spectus/level/medium.rb

@@ -0,0 +1,25 @@
+require_relative 'base'
+
+module Spectus
+  module RequirementLevel
+    # Medium requirement level's class.
+    #
+    # @api private
+    #
+    class Medium < Base
+      # Evaluate the expectation.
+      #
+      # @return [Result::Fail, Result::Pass] report if the medium expectation
+      #   pass or fail.
+      def result
+        state = sandbox
+
+        if state.valid? || state.exception.nil?
+          pass!(state)
+        else
+          fail!(state)
+        end
+      end
+    end
+  end
+end

data/lib/spectus/result/base.rb

@@ -0,0 +1,83 @@
+module Spectus
+  module Result
+    # Result base's module.
+    #
+    # @api public
+    #
+    module Base
+      # Initialize the result class.
+      #
+      # @param message    [String] It is describing the actual/error value.
+      # @param subject    [#object_id] The untrusted object to be tested.
+      # @param challenge  [Symbol] The method to call on the subject.
+      # @param context    [Array] Parameters of the challenge.
+      # @param actual     [#object_id] The value that the subject return through
+      #   its challenge.
+      # @param expected   [Array, Hash, Symbol] The definition of the expected
+      #   value.
+      # @param got        [#object_id] The result of the boolean comparison
+      #   between the actual value and the expected value.
+      # @param error      [#exception, nil] Any possible raised exception.
+      # @param level      [:High, :Medium, :Low] The level of the expectation.
+      # @param negate     [Boolean] Evaluate to a negative assertion.
+      # @param valid      [Boolean] Report if the test was true or false.
+      def initialize(message, subject, challenge, context, actual, expected,
+                     got, error, level, negate, valid)
+
+        if respond_to?(:exception)
+          super(message)
+        else
+          @message  = message
+        end
+
+        @subject    = subject
+        @challenge  = challenge
+        @context    = context
+        @actual     = actual
+        @expected   = expected
+        @got        = got
+        @error      = error
+        @level      = level
+        @negate     = negate
+        @valid      = valid
+      end
+
+      attr_reader :subject, :challenge, :context, :actual, :expected, :got,
+                  :error, :level
+
+      # The value of the negate instance variable.
+      #
+      # @return [Boolean] evaluated to a negative assertion or not.
+      def negate?
+        @negate
+      end
+
+      # The value of the boolean comparison between the actual value and the
+      # expected value.
+      #
+      # @return [Boolean] the test was true or false.
+      def valid?
+        @valid
+      end
+
+      # Report the result.
+      #
+      # @return [Symbol] the properties of the result.
+      def to_h
+        {
+          subject:    subject,
+          challenge:  challenge,
+          context:    context,
+          actual:     actual,
+          expected:   expected,
+          got:        got,
+          error:      error,
+          level:      level,
+          negate:     negate?,
+          valid:      valid?,
+          result:     result?
+        }
+      end
+    end
+  end
+end

data/lib/spectus/result/fail.rb

@@ -0,0 +1,28 @@
+require_relative 'base'
+
+module Spectus
+  module Result
+    # The class that is responsible for reporting that the expectation is false.
+    class Fail < StandardError
+      include Base
+
+      # The value of the expectation of the spec.
+      #
+      # @return [Boolean] the spec was false.
+      def result?
+        false
+      end
+
+      # Identify the state of the result.
+      #
+      # @return [String] the char that identify the state of the result.
+      def to_char
+        if error.nil?
+          'F'
+        else
+          'E'
+        end
+      end
+    end
+  end
+end

data/lib/spectus/result/pass.rb

@@ -0,0 +1,30 @@
+require_relative 'base'
+
+module Spectus
+  module Result
+    # The class that is responsible for reporting that the expectation is true.
+    class Pass
+      include Base
+
+      attr_reader :message
+
+      # The value of the expectation of the spec.
+      #
+      # @return [Boolean] the spec was true.
+      def result?
+        true
+      end
+
+      # Identify the state of the result.
+      #
+      # @return [String] the char that identify the state of the result.
+      def to_char
+        if got
+          '.'
+        else
+          'I'
+        end
+      end
+    end
+  end
+end

data/lib/spectus/sandbox.rb

@@ -1,4 +1,4 @@
-require_relative 'matcher'
+require 'matchi'
 
 module Spectus
   # This class evaluate the expectation with the passed block.
@@ -6,28 +6,44 @@ module Spectus
   # @api private
   #
   class Sandbox
-    attr_reader :exception, :got
+    attr_reader :actual, :exception, :got
 
     # Execute the untested code from the passed block against the definition.
     #
-    # @param [Hash] definition
+    # @param [Array, Hash, Symbol] definition
     # @param [Boolean] negate
-    # @yieldparam actual the value which is compared with the expected value.
-    def initialize(definition, negate, &actual)
-      @got = negate ^ Matcher.pass?(definition, &actual)
+    # @param [#object_id] object the front object which is challenged.
+    # @param [Symbol] meth the name of the method.
+    # @param [Array] args the arguments of the method.
+    def initialize(definition, negate, object, meth, *args)
+      @got = negate ^ matcher(definition).matches? do
+        @actual = object.public_send(meth, *args)
+      end
     rescue => e
       @exception = e
     end
 
-    # Return the result.
+    # Report to the spec's requirement level if the test is true or false.
     #
     # @return [Boolean] Report if the test was true or false.
-    def pass?
+    def valid?
       if defined?(@exception)
         false
       else
         @got
       end
     end
+
+    private
+
+    # Load the matcher.
+    #
+    # @param definition [Array, Hash, Symbol]
+    #
+    # @return [#matches?] the matcher
+    def matcher(definition)
+      params = Array(definition).flatten(1)
+      Matchi.fetch(params.first, *params[1..-1])
+    end
   end
 end

data/spectus.gemspec

@@ -4,23 +4,23 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Cyril Wack']
   spec.email         = ['contact@cyril.email']
 
-  spec.summary       = 'Expectation library with requirement levels.'
-  spec.description   = 'Expectation library with RFC 2119\'s requirement ' \
-                       'levels, and some matchers for Ruby.'
+  spec.summary       = 'Expectation library with RFC 2119 keywords.'
+  spec.description   = "Expectation library with RFC 2119's requirement levels."
   spec.homepage      = 'https://github.com/fixrb/spectus'
   spec.license       = 'MIT'
 
-  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(/^test\//) }
-  spec.executables   = spec.files.grep(/^exe\//) { |f| File.basename(f) }
+  spec.files         =
+    `git ls-files -z`.split("\x0").reject { |f| f.match(/%r{^test}/) }
+  spec.executables   = spec.files.grep(/%r{^exe}/) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'matchi',                 '~> 0.0.4'
+  spec.add_dependency 'matchi',                 '~> 0.0.6'
 
-  spec.add_development_dependency 'bundler',    '~> 1.8'
-  spec.add_development_dependency 'rake',       '~> 10.0'
+  spec.add_development_dependency 'bundler',    '~> 1.9'
+  spec.add_development_dependency 'rake',       '~> 10.4'
   spec.add_development_dependency 'yard',       '~> 0.8'
-  spec.add_development_dependency 'simplecov',  '~> 0.9.1'
-  spec.add_development_dependency 'rubocop',    '~> 0.29'
+  spec.add_development_dependency 'simplecov',  '~> 0.10'
+  spec.add_development_dependency 'rubocop',    '~> 0.31'
 
   private_key = File.expand_path '~/.gem/spectus-gem-private_key.pem'
   if File.exist? private_key

data/test/support/coverage.rb

@@ -0,0 +1,3 @@
+require 'simplecov'
+
+SimpleCov.start

data/test/test_high_fail.rb

@@ -0,0 +1,140 @@
+require_relative File.join 'support', 'coverage'
+require_relative File.join '..', 'lib', 'spectus'
+
+subject = -> { 'foo'.upcase }
+
+begin
+  Spectus.this(&subject).MUST(Eql: 'foo')
+rescue Spectus::Result::Fail => raised_result
+  raise 'failing test' unless raised_result.to_char == 'F'
+  raise 'failing test' unless raised_result.to_h == {
+    subject:    subject,
+    challenge:  :call,
+    context:    [],
+    actual:     'FOO',
+    expected:   { Eql: 'foo' },
+    got:        false,
+    error:      nil,
+    level:      :High,
+    negate:     false,
+    valid:      false,
+    result:     false
+  }
+
+  print '.'
+end
+
+begin
+  Spectus.this(&subject).MUST_NOT(Eql: 'FOO')
+rescue Spectus::Result::Fail => raised_result
+  raise 'failing test' unless raised_result.to_char == 'F'
+  raise 'failing test' unless raised_result.to_h == {
+    subject:    subject,
+    challenge:  :call,
+    context:    [],
+    actual:     'FOO',
+    expected:   { Eql: 'FOO' },
+    got:        false,
+    error:      nil,
+    level:      :High,
+    negate:     true,
+    valid:      false,
+    result:     false
+  }
+
+  print '.'
+end
+
+subject = -> { 'foo'.bar }
+
+begin
+  Spectus.this(&subject).MUST(Eql: 'foo')
+rescue Spectus::Result::Fail => raised_result
+  raise 'failing test' unless raised_result.error.class == NoMethodError
+  raise 'failing test' unless raised_result.to_char == 'E'
+  raise 'failing test' unless raised_result.to_h == {
+    subject:    subject,
+    challenge:  :call,
+    context:    [],
+    actual:     nil,
+    expected:   { Eql: 'foo' },
+    got:        nil,
+    error:      raised_result.error,
+    level:      :High,
+    negate:     false,
+    valid:      false,
+    result:     false
+  }
+
+  print '.'
+end
+
+begin
+  Spectus.this(&subject).MUST_NOT(Eql: 'foo')
+rescue Spectus::Result::Fail => raised_result
+  raise 'failing test' unless raised_result.error.class == NoMethodError
+  raise 'failing test' unless raised_result.to_char == 'E'
+  raise 'failing test' unless raised_result.to_h == {
+    subject:    subject,
+    challenge:  :call,
+    context:    [],
+    actual:     nil,
+    expected:   { Eql: 'foo' },
+    got:        nil,
+    error:      raised_result.error,
+    level:      :High,
+    negate:     true,
+    valid:      false,
+    result:     false
+  }
+
+  print '.'
+end
+
+subject = -> { 'foo'.upcase(:bar) }
+
+begin
+  Spectus.this(&subject).MUST(Eql: 'foo')
+rescue Spectus::Result::Fail => raised_result
+  raise 'failing test' unless raised_result.error.class == ArgumentError
+  raise 'failing test' unless raised_result.to_char == 'E'
+  raise 'failing test' unless raised_result.to_h == {
+    subject:    subject,
+    challenge:  :call,
+    context:    [],
+    actual:     nil,
+    expected:   { Eql: 'foo' },
+    got:        nil,
+    error:      raised_result.error,
+    level:      :High,
+    negate:     false,
+    valid:      false,
+    result:     false
+  }
+
+  print '.'
+end
+
+begin
+  Spectus.this(&subject).MUST_NOT(Eql: 'foo')
+rescue Spectus::Result::Fail => raised_result
+  raise 'failing test' unless raised_result.error.class == ArgumentError
+  raise 'failing test' unless raised_result.to_char == 'E'
+  raise 'failing test' unless raised_result.to_h == {
+    subject:    subject,
+    challenge:  :call,
+    context:    [],
+    actual:     nil,
+    expected:   { Eql: 'foo' },
+    got:        nil,
+    error:      raised_result.error,
+    level:      :High,
+    negate:     true,
+    valid:      false,
+    result:     false
+  }
+
+  print '.'
+end
+
+puts

data/test/test_high_pass.rb

@@ -0,0 +1,44 @@
+require_relative File.join 'support', 'coverage'
+require_relative File.join '..', 'lib', 'spectus'
+
+subject = -> { 'foo'.upcase }
+
+result = Spectus.this(&subject).MUST(Eql: 'FOO')
+
+fail 'failing test' unless result.to_char == '.'
+fail 'failing test' unless result.to_h == {
+  subject:    subject,
+  challenge:  :call,
+  context:    [],
+  actual:     'FOO',
+  expected:   { Eql: 'FOO' },
+  got:        true,
+  error:      nil,
+  level:      :High,
+  negate:     false,
+  valid:      true,
+  result:     true
+}
+
+print '.'
+
+result = Spectus.this(&subject).MUST_NOT(Eql: 'foo')
+
+fail 'failing test' unless result.to_char == '.'
+fail 'failing test' unless result.to_h == {
+  subject:    subject,
+  challenge:  :call,
+  context:    [],
+  actual:     'FOO',
+  expected:   { Eql: 'foo' },
+  got:        true,
+  error:      nil,
+  level:      :High,
+  negate:     true,
+  valid:      true,
+  result:     true
+}
+
+print '.'
+
+puts