oktest 1.0.0 → 1.1.1

data/Rakefile.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 ###
-### $Release: 1.0.0 $
+### $Release: 1.1.1 $
 ### $Copyright: copyright(c) 2011-2021 kuwata-lab.com all rights reserved $
 ### $License: MIT License $
 ###

data/lib/oktest.rb

@@ -1,16 +1,18 @@
 # -*- coding: utf-8 -*-
 
 ###
-### $Release: 1.0.0 $
+### $Release: 1.1.1 $
 ### $Copyright: copyright(c) 2011-2021 kuwata-lab.com all rights reserved $
 ### $License: MIT License $
 ###
 
+require 'set'
+
 
 module Oktest
 
 
-  VERSION = '$Release: 1.0.0 $'.split()[1]
+  VERSION = '$Release: 1.1.1 $'.split()[1]
 
 
   class OktestError < StandardError
@@ -114,6 +116,10 @@ module Oktest
 
     def ===(expected)
       __done()
+      #; [!mjh4d] raises error when combination of 'not_ok()' and matcher object.
+      if @bool == false && @actual.is_a?(Matcher)
+        raise OktestError, "negative `===` is not available with matcher object."
+      end
       #; [!42f6a] raises assertion error when failed.
       #; [!vhvyu] is avaialbe with NOT.
       __assert(@bool == (@actual === expected)) {
@@ -264,10 +270,10 @@ module Oktest
 
     def raise!(errcls=nil, errmsg=nil, &b)
       #; [!8k6ee] compares error class by '.is_a?' instead of '=='.
-      return raise?(errcls, errmsg, subclass: true, &b)
+      return raise?(errcls, errmsg, _subclass: true, &b)
     end
 
-    def raise?(errcls=nil, errmsg=nil, subclass: false, &b)
+    def raise?(errcls=nil, errmsg=nil, _subclass: false, &b)
       __done()
       #; [!2rnni] 1st argument can be error message string or rexp.
       if errmsg.nil? && ! errcls.nil? && ! (errcls.is_a?(Class) && errcls <= Exception)
@@ -289,8 +295,8 @@ module Oktest
           #; [!lq6jv] compares error class with '==' operator, not '.is_a?'.
           elsif exc.class == errcls    # not `exc.is_a?(errcls)`
             nil
-          #; [!hwg0z] compares error class with '.is_a?' if 'subclass: true' specified.
-          elsif subclass && exc.class < errcls
+          #; [!hwg0z] compares error class with '.is_a?' if '_subclass: true' specified.
+          elsif _subclass && exc.class < errcls
             nil
           #; [!4n3ed] reraises if exception is not matched to specified error class.
           else
@@ -328,8 +334,8 @@ module Oktest
           #; [!smprc] compares error class with '==' operator, not '.is_a?'.
           elsif exc.class == errcls    # not `exc.is_a?(errcls)`
             __assert(false) { "#{errcls.inspect} should not be raised but got #{exc.inspect}." }
-          #; [!34nd8] compares error class with '.is_a?' if 'subclass: true' specified.
-          elsif subclass && exc.class < errcls
+          #; [!34nd8] compares error class with '.is_a?' if '_subclass: true' specified.
+          elsif _subclass && exc.class < errcls
             __assert(false) { "#{errcls.inspect} should not be raised but got #{exc.inspect}." }
           #; [!shxne] reraises exception if different from specified error class.
           else
@@ -548,6 +554,246 @@ module Oktest
   end
 
 
+  class Matcher
+
+    def initialize(actual)
+      @actual = actual
+    end
+
+    def ===(expected)
+      #; [!spybn] raises NotImplementedError.
+      raise NotImplementedError.new("#{self.class.name}#===(): not implemented yet.")
+    end
+
+    def ==(expected)
+      #; [!ymt1b] raises OktestError.
+      raise OktestError, "JSON(): use `===` instead of `==`."
+    end
+
+    def fail(errmsg)
+      #; [!8qpsd] raises assertion error.
+      raise Oktest::FAIL_EXCEPTION, errmsg
+    end
+
+  end
+
+
+  class JsonMatcher < Matcher
+
+    def ===(expected)
+      #; [!4uf1o] raises assertion error when JSON not matched.
+      _compare([], @actual, expected)
+      #; [!0g0u4] returns true when JSON matched.
+      return true
+    end
+
+    private
+
+    def _compare?(path, a, e)
+      #; [!nkvqo] returns true when nothing raised.
+      #; [!57m2j] returns false when assertion error raised.
+      _compare(path, a, e)
+      return true
+    rescue FAIL_EXCEPTION
+      return false
+    end
+
+    def _compare(path, a, e)
+      if a.is_a?(Hash) && e.is_a?(Hash)
+        _compare_hash(path, a, e)
+      elsif a.is_a?(Array) && e.is_a?(Array)
+        _compare_array(path, a, e)
+      elsif e.is_a?(Enumerator)
+        _compare_enumerator(path, a, e)
+      elsif e.is_a?(OR)
+        _compare_or(path, a, e)
+      elsif e.is_a?(AND)
+        _compare_and(path, a, e)
+      else
+        _compare_value(path, a, e)
+      end
+    end
+
+    def _compare_value(path, a, e)
+      #; [!1ukbv] scalar value matches to integer, string, bool, and so son.
+      #; [!8o55d] class object matches to instance object.
+      #; [!s625d] regexp object matches to string value.
+      #; [!aqkk0] range object matches to scalar value.
+      #; [!a7bfs] Set object matches to enum value.
+      e === a  or fail <<"END"
+$<JSON>#{_path(path)}: $<expected> === $<actual> : failed.
+    $<actual>:   #{a.inspect}
+    $<expected>: #{e.inspect}
+END
+      #; [!4ymj2] fails when actual value is not matched to item class of range object.
+      if e.is_a?(Range)
+        expected_class = (e.begin || e.end).class
+        a.is_a?(expected_class)  or fail <<"END"
+$<JSON>#{_path(path)}: expected #{expected_class.name} value, but got #{a.class.name} value.
+    $<actual>:   #{a.inspect}
+    $<expected>: #{e.inspect}
+END
+      end
+    end
+
+    def _compare_array(path, a, e)
+      #; [!bz74w] fails when array lengths are different.
+      a.length == e.length  or fail <<"END"
+$<JSON>#{_path(path)}: $<actual>.length == $<expected>.length : failed.
+    $<actual>.length:   #{a.length}
+    $<expected>.length: #{e.length}
+    $<actual>:   #{a.inspect}
+    $<expected>: #{e.inspect}
+END
+      #; [!lh6d6] compares array items recursively.
+      path.push(nil)
+      i = -1
+      a.zip(e) do |a2, e2|
+        path[-1] = (i += 1)
+        _compare(path, a2, e2)
+      end
+      path.pop()
+    end
+
+    def _compare_hash(path, a, e)
+      #; [!rkv0z] compares two hashes with converting keys into string.
+      a2 = {}; a.each {|k, v| a2[k.to_s] = v }
+      e2 = {}; e.each {|k, v| e2[k.to_s] = v }
+      #; [!fmxyg] compares hash objects recursively.
+      path.push(nil)
+      a2.each_key do |k|
+        path[-1] = k
+        if e2.key?(k)
+          _compare(path, a2[k], e2[k])
+        #; [!jbyv6] key 'aaa?' represents optional key.
+        elsif e2.key?("#{k}?")
+          _compare(path, a2[k], e2["#{k}?"]) unless a2[k].nil?
+        #; [!uc4ag] key '*' matches to any key name.
+        elsif e2.key?("*")
+          _compare(path, a2[k], e2["*"])
+        #; [!mpbvu] fails when unexpected key exists in actual hash.
+        else
+          fail <<"END"
+$<JSON>#{_path(path)}: unexpected key.
+    $<actual>:   #{a2[k].inspect}
+END
+        end
+      end
+      path.pop()
+      #; [!4oasq] fails when expected key not exist in actual hash.
+      (e2.keys - a2.keys).each do |k|
+        k =~ /\?\z/ || k == "*"  or fail <<"END"
+$<JSON>#{_path(path)}: key \"#{k}\" expected but not found.
+    $<actual>.keys:   #{a2.keys.sort.inspect[1...-1]}
+    $<expected>.keys: #{e2.keys.sort.inspect[1...-1]}
+END
+      end
+    end
+
+    def _compare_enumerator(path, a, e)
+      #; [!ljrmc] fails when expected is an Enumerator object and actual is not an array.
+      e2 = e.first
+      a.is_a?(Array)  or fail <<"END"
+$<JSON>#{_path(path)}: Array value expected but got #{a.class.name} value.
+    $<actual>:   #{a.inspect}
+    $<expected>: [#{e2.inspect}].each
+END
+      #; [!sh5cg] Enumerator object matches to repeat of rule.
+      path.push(nil)
+      a.each_with_index do |a2, i|
+        path[-1] = i
+        _compare(path, a2, e2)
+      end
+      path.pop()
+    end
+
+    def _compare_or(path, a, e)
+      #; [!eqr3b] `OR()` matches to any of arguments.
+      #; [!5ybfg] `OR()` can contain `AND()`.
+      passed = e.items.any? {|e2| _compare?(path, a, e2) }
+      passed  or fail <<"END"
+$<JSON>#{_path(path)}: $<expected> === $<actual> : failed.
+    $<actual>:   #{a.inspect}
+    $<expected>: OR(#{e.items.collect(&:inspect).join(', ')})
+END
+    end
+
+    def _compare_and(path, a, e)
+      #; [!4hk96] `AND()` matches to all of arguments.
+      #; [!scx22] `AND()` can contain `OR()`.
+      failed = e.items.find {|e2| ! _compare?(path, a, e2) }
+      ! failed  or fail <<"END"
+$<JSON>#{_path(path)}: $<expected> === $<actual> : failed.
+    $<actual>:   #{a.inspect}
+    $<expected>: AND(#{failed.inspect})
+END
+    end
+
+    def _path(path)
+      #return path.collect {|x| "/#{x}" }.join()
+      return path.collect {|x| "[#{x.inspect}]" }.join()
+    end
+
+    protected
+
+    class OR
+      def initialize(*items)
+        @items = items
+      end
+      attr_reader :items
+      def inspect()
+        #; [!2mu33] returns 'OR(...)' string.
+        return "OR(#{@items.collect(&:inspect).join(', ')})"
+      end
+    end
+
+    class AND
+      def initialize(*items)
+        @items = items
+      end
+      attr_reader :items
+      def inspect()
+        #; [!w43ag] returns 'AND(...)' string.
+        return "AND(#{@items.collect(&:inspect).join(', ')})"
+      end
+    end
+
+    class Enum < Set
+      alias === include?     # Ruby 2.4 or older doesn't have 'Set#==='.
+      def inspect()
+        #; [!fam11] returns 'Enum(...)' string.
+        return "Enum(#{self.collect(&:inspect).join(', ')})"
+      end
+    end
+
+    class Length
+      def initialize(expected)
+        @expected = expected
+      end
+      def ===(actual)
+        #; [!03ozi] compares length of actual value with expected value.
+        return @expected === actual.length
+      end
+      def inspect()
+        #; [!nwv3e] returns 'Length(n)' string.
+        return "Length(#{@expected.inspect})"
+      end
+    end
+
+    class Any
+      def ===(actual)
+        #; [!mzion] returns true in any case.
+        true
+      end
+      def inspect()
+        #; [!6f0yv] returns 'Any()' string.
+        return "Any()"
+      end
+    end
+
+  end
+
+
   class Context
     ## * Context class is separated from ScopeNode, TopicNode, and SpecLeaf.
     ## * `topic()` and `spec()` creates subclass of Context class,
@@ -891,11 +1137,20 @@ module Oktest
   end
 
   def self.scope(tag: nil, &block)
-    #; [!vxoy1] creates new scope object.
-    #; [!rsimc] adds scope object as child of THE_GLOBAL_SCOPE.
+    #; [!kem4y] detects test script filename.
     location = caller(1).first  # caller() makes performance slower, but necessary.
     filename = location =~ /:\d+/ ? $` : nil
-    filename = filename.sub(/\A\.\//, '')
+    #; [!6ullm] changes test script filename from absolute path to relative path.
+    if filename
+      pwd = Dir.pwd()
+      if filename.start_with?(pwd)
+        filename = filename[pwd.length..-1].sub(/\A\//, '')
+      elsif filename.start_with?('./')
+        filename = filename[2..-1]
+      end
+    end
+    #; [!vxoy1] creates new scope object.
+    #; [!rsimc] adds scope object as child of THE_GLOBAL_SCOPE.
     scope = ScopeNode.new(THE_GLOBAL_SCOPE, filename, tag: tag)
     #; [!jmc4q] raises error when nested called.
     self.__scope(scope, &block)
@@ -1107,6 +1362,41 @@ module Oktest
       return Benry::Recorder.new
     end
 
+    def JSON(actual)
+      #; [!n0k03] creates JsonMatcher object.
+      return JsonMatcher.new(actual)
+    end
+
+    def Enum(*values)
+      #; [!fbfr0] creates Enum object which is a subclass of Set.
+      return JsonMatcher::Enum.new(values)
+    end
+
+    def Bool()
+      #; [!vub5j] creates a set of true and false.
+      return Enum(true, false)
+    end
+
+    def OR(*args)
+      #; [!9e8im] creates `OR` object.
+      return JsonMatcher::OR.new(*args)
+    end
+
+    def AND(*args)
+      #; [!38jln] creates `AND` object.
+      return JsonMatcher::AND.new(*args)
+    end
+
+    def Length(n)
+      #; [!qqas3] creates Length object.
+      return JsonMatcher::Length.new(n)
+    end
+
+    def Any()
+      #; [!dlo1o] creates an 'Any' object.
+      return JsonMatcher::Any.new
+    end
+
   end
 
 
@@ -1206,11 +1496,25 @@ module Oktest
       @reporter.exit_all(self)
     end
 
+    def _spec_first(node)
+      a1, a2 = node.each_child.partition {|c|
+        c.is_a?(SpecLeaf) || (c.is_a?(TopicNode) && c._prefix != '*')
+      }
+      return a1+a2
+    end
+    private :_spec_first
+
     def visit_scope(scope, depth, parent)
       @reporter.enter_scope(scope) unless scope.equal?(THE_GLOBAL_SCOPE)
       #; [!5anr7] calls before_all and after_all blocks.
       call_before_all_block(scope)
-      scope.each_child {|c| c.accept_visitor(self, depth+1, scope) }
+      #; [!c5cw0] run specs and case_when in advance of specs and topics when SimpleReporter.
+      if @reporter.order_policy() == :spec_first
+        _spec_first(scope).each {|c| c.accept_visitor(self, depth+1, scope) }
+      else
+        scope.each_child {|c| c.accept_visitor(self, depth+1, scope) }
+      end
+      #
       call_after_all_block(scope)
       @reporter.exit_scope(scope) unless scope.equal?(THE_GLOBAL_SCOPE)
     end
@@ -1219,7 +1523,13 @@ module Oktest
       @reporter.enter_topic(topic, depth)
       #; [!i3yfv] calls 'before_all' and 'after_all' blocks.
       call_before_all_block(topic)
-      topic.each_child {|c| c.accept_visitor(self, depth+1, topic) }
+      #; [!p3a5o] run specs and case_when in advance of specs and topics when SimpleReporter.
+      if @reporter.order_policy() == :spec_first
+        _spec_first(topic).each {|c| c.accept_visitor(self, depth+1, topic) }
+      else
+        topic.each_child {|c| c.accept_visitor(self, depth+1, topic) }
+      end
+      #
       call_after_all_block(topic)
       @reporter.exit_topic(topic, depth)
     end
@@ -1420,6 +1730,7 @@ module Oktest
     def exit_spec(spec, depth, status, error, parent); end
     #
     def counts; {}; end
+    def order_policy(); nil; end     # :spec_first or nil
 
   end
 
@@ -1430,7 +1741,7 @@ module Oktest
     CHARS  = { :PASS=>'.', :FAIL=>'f', :ERROR=>'E', :SKIP=>'s', :TODO=>'t' }
 
 
-    def initialize
+    def initialize()
       @exceptions = []
       @counts = {}
     end
@@ -1573,6 +1884,10 @@ module Oktest
 
     LABELS = { :PASS=>'pass', :FAIL=>'Fail', :ERROR=>'ERROR', :SKIP=>'Skip', :TODO=>'TODO' }
 
+    def enter_scope(scope)
+      puts "## #{scope.filename}"
+    end
+
     def enter_topic(topic, depth)
       super
       puts "#{'  ' * (depth - 1)}#{topic._prefix} #{Color.topic(topic.target)}"
@@ -1606,6 +1921,64 @@ module Oktest
 
 
   class SimpleReporter < BaseReporter
+    #; [!jxa1b] reports topics and progress.
+
+    def initialize()
+      super
+      @_nl = true
+    end
+
+    def order_policy()
+      :spec_first
+    end
+
+    def _nl()
+      (puts(); @_nl = true) unless @_nl
+    end
+    private :_nl
+
+    def _nl_off()
+      @_nl = false
+    end
+    private :_nl_off
+
+    def enter_scope(scope)
+      _nl()
+      puts "## #{scope.filename}"
+    end
+
+    def exit_scope(scope)
+      _nl()
+      print_exceptions()
+    end
+
+    def enter_topic(topic, depth)
+      super
+      return if topic._prefix == '-'
+      _nl()
+      print "#{'  ' * (depth - 1)}#{topic._prefix} #{Color.topic(topic.target)}: "
+      $stdout.flush()
+      _nl_off()
+    end
+
+    def exit_topic(topic, depth)
+      super
+      return if topic._prefix == '-'
+      _nl()
+      print_exceptions()
+    end
+
+    def exit_spec(spec, depth, status, error, parent)
+      super
+      print Color.status(status, CHARS[status] || '?')
+      $stdout.flush
+      _nl_off()
+    end
+
+  end
+
+
+  class CompactReporter < BaseReporter
     #; [!xfd5o] reports filename.
 
     def enter_scope(scope)
@@ -1672,14 +2045,13 @@ module Oktest
   REPORTER_CLASSES = {
     'verbose' => VerboseReporter,  'v' => VerboseReporter,
     'simple'  => SimpleReporter,   's' => SimpleReporter,
+    'compact' => CompactReporter,  'c' => CompactReporter,
     'plain'   => PlainReporter,    'p' => PlainReporter,
     'quiet'   => QuietReporter,    'q' => QuietReporter,
   }
 
 
   def self.run(reporter: nil, style: nil)
-    #; [!kfi8b] do nothing when 'Oktest.scope()' not called.
-    return unless THE_GLOBAL_SCOPE.has_child?
     #; [!6xn3t] creates reporter object according to 'style:' keyword arg.
     klass = (style ? REPORTER_CLASSES[style] : REPORTER_CLASS)  or
       raise ArgumentError, "#{style.inspect}: unknown style."
@@ -2145,7 +2517,7 @@ END
         return 0
       end
       #; [!65vdx] prints help message if no arguments specified.
-      if filenames.empty?
+      if filenames.empty? && !THE_GLOBAL_SCOPE.has_child?
         puts help_message()
         return 0
       end
@@ -2176,7 +2548,8 @@ END
       Config.auto_run = false
       #; [!18qpe] runs test scripts.
       #; [!0qd92] '-s verbose' or '-sv' option prints test results in verbose mode.
-      #; [!ef5v7] '-s simple' or '-ss' option prints test results in simple mode.
+      #; [!zfdr5] '-s simple' or '-ss' option prints test results in simple mode.
+      #; [!ef5v7] '-s compact' or '-sc' option prints test results in compact mode.
       #; [!244te] '-s plain' or '-sp' option prints test results in plain mode.
       #; [!ai61w] '-s quiet' or '-sq' option prints test results in quiet mode.
       n_errors = Oktest.run(:style=>opts.style)
@@ -2207,6 +2580,7 @@ END
       }
       parser.on('-F PATTERN') {|val|
         #; [!71h2x] '-F ...' option will be error.
+        #; [!j01y7] if filerting by '-F' matched nothing, then prints zero result.
         val =~ /\A(topic|spec|tag|sid)(=|!=)/  or
           raise OptionParser::InvalidArgument, val
         opts.filter = val
@@ -2237,7 +2611,7 @@ END
 Usage: %{command} [<options>] [<file-or-directory>...]
   -h, --help             : show help
       --version          : print version
-  -s <STYLE>             : report style (verbose/simple/plain/quiet, or v/s/p/q)
+  -s <REPORT-STYLE>      : verbose/simple/compact/plain/quiet, or v/s/c/p/q
   -F <PATTERN>           : filter topic or spec with pattern (see below)
       --color[={on|off}] : enable/disable output coloring forcedly
   -C, --create           : print test code skeleton