spectre-core 1.12.3 → 1.14.0

data/lib/spectre/logger.rb

@@ -2,7 +2,7 @@ require_relative '../spectre'
 require 'date'
 
 module Spectre
-  module Logger
+  module Logging
     module Status
       OK = '[ok]'
       FAILED = '[failed]'
@@ -12,6 +12,31 @@ module Spectre
       DEBUG = '[debug]'
     end
 
+    class ModuleLogger
+      def initialize config, name
+        @name = name
+        @debug = config['debug']
+        @logger = ::Logger.new(config['log_file'], progname: name)
+
+        @logger.level = @debug ? ::Logger::DEBUG : ::Logger::INFO
+      end
+
+      def info message
+        @logger.info(message)
+        Logging.add_log(message, :info, @name)
+      end
+
+      def debug message
+        @logger.debug(message)
+        Logging.add_log(message, :debug, @name) if @debug
+      end
+
+      def warn message
+        @logger.warn(message)
+        Logging.add_log(message, :warn, @name)
+      end
+    end
+
     class << self
       @@debug = false
       @@logger = []
@@ -93,24 +118,24 @@ module Spectre
       end
 
       def log_info message
-        add_log(message)
+        add_log(message, :info)
         delegate(:log_info, message)
       end
 
       def log_debug message
         return unless @@debug
 
-        add_log(message)
+        add_log(message, :debug)
         delegate(:log_debug, message)
       end
 
       def log_error spec, exception
-        add_log(exception)
+        add_log(exception, :error)
         delegate(:log_error, spec, exception)
       end
 
-      def log_skipped spec
-        delegate(:log_skipped, spec)
+      def log_skipped spec, message=nil
+        delegate(:log_skipped, spec, message)
       end
 
       def log_status desc, status, annotation=nil
@@ -118,9 +143,15 @@ module Spectre
       end
 
       def group desc
-        Logger.start_group desc
+        Logging.start_group desc
         yield
-        Logger.end_group desc
+        Logging.end_group desc
+      end
+
+      def add_log message, level, logger_name='spectre'
+        return unless Spectre::Runner.current
+
+        Spectre::Runner.current.log.append([DateTime.now, message, level, logger_name])
       end
 
       alias_method :info, :log_info
@@ -135,10 +166,6 @@ module Spectre
           logger.send(method, *args) if logger.respond_to? method
         end
       end
-
-      def add_log message
-        Spectre::Runner.current.log.append([DateTime.now, message])
-      end
     end
 
     Spectre.delegate :log, :info, :debug, :group, :separate, to: self

data/lib/spectre/mixin.rb

@@ -12,12 +12,12 @@ module Spectre
 
       def required params, *keys
         missing_keys = keys.select { |x| !params.to_h.key? x }
-        Spectre::Logger.log_debug("required parameters for '#{@__desc}': #{keys.join ', '}")
+        Spectre::Logging.log_debug("required parameters for '#{@__desc}': #{keys.join ', '}")
         raise ArgumentError, "mixin '#{@__desc}' requires #{keys.join ', '}, but only has #{missing_keys.join ', '} given" unless missing_keys.empty?
       end
 
       def optional params, *keys
-        Spectre::Logger.log_debug("optional parameters for '#{@__desc}': #{keys.join ', '}")
+        Spectre::Logging.log_debug("optional parameters for '#{@__desc}': #{keys.join ', '}")
         params
       end
     end
@@ -32,7 +32,7 @@ module Spectre
       def run desc, with: []
         raise "no mixin with desc '#{desc}' defined" unless @@mixins.key? desc
 
-        Spectre::Logger.log_debug "running mixin '#{desc}'"
+        Spectre::Logging.log_debug "running mixin '#{desc}'"
 
         params = with || {}
 

data/lib/spectre/reporter/console.rb

@@ -14,36 +14,34 @@ module Spectre::Reporter
       run_infos
         .select { |x| x.error != nil or x.failure != nil }
         .each_with_index do |run_info, index|
-        spec = run_info.spec
+          report_str += "\n#{index+1}) #{format_title(run_info)}\n"
 
-        report_str += "\n#{index+1}) #{format_title(run_info)}\n"
+          if run_info.failure
+            report_str += "     Expected #{run_info.failure.expectation}"
+            report_str += " with #{run_info.data}" if run_info.data
 
-        if run_info.failure
-          report_str += "     Expected #{run_info.failure.expectation}"
-          report_str += " with #{run_info.data}" if run_info.data
+            report_str += " but it failed"
 
-          report_str += " but it failed"
+            if run_info.failure.cause
+              report_str += "\n     with an unexpected error:\n"
+              report_str += format_exception(run_info.failure.cause)
 
-          if run_info.failure.cause
-            report_str += "\n     with an unexpected error:\n"
-            report_str += format_exception(run_info.failure.cause)
+            elsif run_info.failure.message and not run_info.failure.message.empty?
+              report_str += " with:\n     #{run_info.failure.message}"
 
-          elsif run_info.failure.message and not run_info.failure.message.empty?
-            report_str += " with:\n     #{run_info.failure.message}"
+            else
+              report_str += '.'
+            end
+
+            report_str += "\n"
+            failures += 1
 
           else
-            report_str += '.'
+            report_str += "     but an unexpected error occurred during run\n"
+            report_str += format_exception(run_info.error)
+            errors += 1
           end
-
-          report_str += "\n"
-          failures += 1
-
-        else
-          report_str += "     but an unexpected error occurred during run\n"
-          report_str += format_exception(run_info.error)
-          errors += 1
         end
-      end
 
       if failures + errors > 0
         summary = ''
@@ -54,7 +52,6 @@ module Spectre::Reporter
         summary += "#{run_infos.length} total"
         print "\n#{summary}\n".red
       else
-        summary = ''
         summary = "\nRun finished successfully"
         summary += " (#{skipped} skipped)" if skipped > 0
         print "#{summary}\n".green

data/lib/spectre.rb

@@ -1,8 +1,8 @@
 module Spectre
   module Version
     MAJOR = 1
-    MINOR = 12
-    TINY  = 3
+    MINOR = 14
+    TINY  = 0
   end
 
   VERSION = [Version::MAJOR, Version::MINOR, Version::TINY].compact * '.'
@@ -10,7 +10,7 @@ module Spectre
 
   class ::Hash
     def deep_merge!(second)
-      merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge!(v2, &merger) : v2 }
+      merger = proc { |_key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge!(v2, &merger) : v2 }
       self.merge!(second, &merger)
     end
 
@@ -34,9 +34,6 @@ module Spectre
 
 
   class SpectreError < Exception
-    def initialize message
-      super message
-    end
   end
 
   class ExpectationFailure < Exception
@@ -48,6 +45,9 @@ module Spectre
     end
   end
 
+  class SpectreSkip < Interrupt
+  end
+
 
   ###########################################
   # Internal Classes
@@ -111,7 +111,7 @@ module Spectre
 
   class RunInfo
     attr_accessor :spec, :data, :started, :finished, :error, :failure, :skipped
-    attr_reader :log, :properties
+    attr_reader :expectations, :log, :properties
 
     def initialize spec, data=nil
       @spec = spec
@@ -122,6 +122,7 @@ module Spectre
       @failure = nil
       @skipped = false
       @log = []
+      @expectations = []
       @properties = {}
     end
 
@@ -134,12 +135,24 @@ module Spectre
     end
 
     def failed?
+      @failure != nil
+    end
+
+    def error?
       @error != nil
     end
+
+    def status
+      return :error if error?
+      return :failed if failed?
+      return :skipped if skipped?
+
+      return :success
+    end
   end
 
   class Runner
-    @@current
+    @@current = nil
 
     def self.current
       @@current
@@ -148,11 +161,11 @@ module Spectre
     def run specs
       runs = []
 
-      specs.group_by { |x| x.subject }.each do |subject, spec_group|
-        Logger.log_subject subject do
-          spec_group.group_by { |x| x.context }.each do |context, specs|
-            Logger.log_context(context) do
-              runs.concat run_context(context, specs)
+      specs.group_by { |x| x.subject }.each do |subject, subject_specs|
+        Logging.log_subject subject do
+          subject_specs.group_by { |x| x.context }.each do |context, context_specs|
+            Logging.log_context(context) do
+              runs.concat run_context(context, context_specs)
             end
           end
         end
@@ -166,8 +179,8 @@ module Spectre
     def run_context context, specs
       runs = []
 
-      if context.__setup_blocks.count > 0
-        setup_run = run_blocks('setup', context, context.__setup_blocks)
+      context.__setup_blocks.each do |setup_spec|
+        setup_run = run_setup(setup_spec)
         runs << setup_run
         return runs if setup_run.error or setup_run.failure
       end
@@ -180,47 +193,42 @@ module Spectre
             spec.data
               .map { |x| x.is_a?(Hash) ? OpenStruct.new(x) : x }
               .each do |data|
-                Logger.log_spec(spec, data) do
+                Logging.log_spec(spec, data) do
                   runs << run_spec(spec, data)
                 end
               end
           else
-            Logger.log_spec(spec) do
+            Logging.log_spec(spec) do
               runs << run_spec(spec)
             end
           end
         end
       ensure
-        if context.__teardown_blocks.count > 0
-          runs << run_blocks('teardown', context, context.__teardown_blocks)
+        context.__teardown_blocks.each do |teardown_spec|
+          runs << run_setup(teardown_spec)
         end
       end
 
       runs
     end
 
-    def run_blocks name, context, blocks
-      ctx = SpecContext.new context.__subject, name
-      spec = Spec.new name, context.__subject, name, [], nil, nil, ctx, nil
-
-      run_info = RunInfo.new spec
+    def run_setup spec
+      run_info = RunInfo.new(spec)
 
       @@current = run_info
 
       run_info.started = Time.now
 
-      Logger.log_context ctx do
+      Logging.log_context(spec.context) do
         begin
-          blocks.each do |block|
-            block.call
-          end
+          spec.block.call()
 
           run_info.finished = Time.now
         rescue ExpectationFailure => e
           run_info.failure = e
         rescue Exception => e
           run_info.error = e
-          Logger.log_error spec, e
+          Logging.log_error(spec, e)
         end
       end
 
@@ -240,9 +248,9 @@ module Spectre
 
       begin
         if spec.context.__before_blocks.count > 0
-          before_ctx = SpecContext.new(spec.subject, 'before')
+          before_ctx = SpecContext.new(spec.subject, 'before', spec.context)
 
-          Logger.log_context before_ctx do
+          Logging.log_context before_ctx do
             spec.context.__before_blocks.each do |block|
               block.call(data)
             end
@@ -252,17 +260,20 @@ module Spectre
         spec.block.call(data)
       rescue ExpectationFailure => e
         run_info.failure = e
+      rescue SpectreSkip => e
+        run_info.skipped = true
+        Logging.log_skipped(spec, e.message)
       rescue Interrupt
         run_info.skipped = true
-        Logger.log_skipped spec
+        Logging.log_skipped(spec, 'canceled by user')
       rescue Exception => e
         run_info.error = e
-        Logger.log_error spec, e
+        Logging.log_error(spec, e)
       ensure
         if spec.context.__after_blocks.count > 0
-          after_ctx = SpecContext.new(spec.subject, 'after')
+          after_ctx = SpecContext.new(spec.subject, 'after', spec.context)
 
-          Logger.log_context after_ctx do
+          Logging.log_context after_ctx do
             begin
               spec.context.__after_blocks.each do |block|
                 block.call
@@ -273,7 +284,7 @@ module Spectre
               run_info.failure = e
             rescue Exception => e
               run_info.error = e
-              Logger.log_error spec, e
+              Logging.log_error(spec, e)
             end
           end
         end
@@ -294,11 +305,12 @@ module Spectre
 
 
   class SpecContext < DslClass
-    attr_reader :__subject, :__desc, :__before_blocks, :__after_blocks, :__setup_blocks, :__teardown_blocks
+    attr_reader :__subject, :__desc, :__parent, :__before_blocks, :__after_blocks, :__setup_blocks, :__teardown_blocks
 
-    def initialize subject, desc=nil
+    def initialize subject, desc=nil, parent=nil
       @__subject = subject
       @__desc = desc
+      @__parent = parent
 
       @__before_blocks = []
       @__after_blocks = []
@@ -307,20 +319,7 @@ module Spectre
     end
 
     def it desc, tags: [], with: [], &block
-      # Get the file, where the spec is defined.
-      # Nasty, but it works
-      # Maybe there is another way, but this works for now
-      spec_file = nil
-      begin
-        raise
-      rescue => e
-        spec_file = e.backtrace
-          .select { |file| !file.include? 'lib/spectre' }
-          .first
-          .match(/(.*\.rb):\d+/)
-          .captures
-          .first
-      end
+      spec_file = get_file()
 
       @__subject.add_spec(desc, tags, with, block, self, spec_file)
     end
@@ -334,17 +333,44 @@ module Spectre
     end
 
     def setup &block
-      @__setup_blocks << block
+      name = "#{@__subject.name}-setup"
+      spec_file = get_file()
+
+      setup_ctx = SpecContext.new(@__subject, 'setup', self)
+      @__setup_blocks << Spec.new(name, @__subject, 'setup', [], nil, block, setup_ctx, spec_file)
     end
 
     def teardown &block
-      @__teardown_blocks << block
+      name = "#{@__subject.name}-teardown"
+      spec_file = get_file()
+
+      teardown_ctx = SpecContext.new(@__subject, 'teardown', self)
+      @__teardown_blocks << Spec.new(name, @__subject, 'teardown', [], nil, block, teardown_ctx, spec_file)
     end
 
     def context desc=nil, &block
-      ctx = SpecContext.new(@__subject, desc)
+      ctx = SpecContext.new(@__subject, desc, self)
       ctx._evaluate &block
     end
+
+    private
+
+    def get_file
+      # Get the file, where the spec is defined.
+      # Nasty, but it works
+      # Maybe there is another way, but this works for now
+
+      begin
+        raise
+      rescue => e
+        return e.backtrace
+          .select { |file| !file.include? 'lib/spectre' }
+          .first
+          .match(/(.*\.rb):\d+/)
+          .captures
+          .first
+      end
+    end
   end
 
 
@@ -397,14 +423,14 @@ module Spectre
 
     def tag? tags, tag_exp
       tags = tags.map { |x| x.to_s }
-      all_tags = tag_exp.split '+'
+      all_tags = tag_exp.split('+')
       included_tags = all_tags.select { |x| !x.start_with? '!' }
       excluded_tags = all_tags.select { |x| x.start_with? '!' }.map { |x| x[1..-1] }
       included_tags & tags == included_tags and excluded_tags & tags == []
     end
 
     def delegate *method_names, to: nil
-      Spectre::Delegator.delegate *method_names, to
+      Spectre::Delegator.delegate(*method_names, to)
     end
 
     def register &block
@@ -438,9 +464,13 @@ module Spectre
     def property key, val
       Spectre::Runner.current.properties[key] = val
     end
+
+    def skip message=nil
+      raise SpectreSkip.new(message)
+    end
   end
 
-  delegate :describe, :property, to: Spectre
+  delegate :describe, :property, :skip, to: Spectre
 end
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spectre-core
 version: !ruby/object:Gem::Version
-  version: 1.12.3
+  version: 1.14.0
 platform: ruby
 authors:
 - Christian Neubauer
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-03-01 00:00:00.000000000 Z
+date: 2022-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ectoplasm
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: 1.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: 1.2.3
 - !ruby/object:Gem::Dependency
   name: jsonpath
   requirement: !ruby/object:Gem::Requirement
@@ -49,6 +49,7 @@ files:
 - exe/spectre
 - lib/spectre.rb
 - lib/spectre/assertion.rb
+- lib/spectre/async.rb
 - lib/spectre/bag.rb
 - lib/spectre/curl.rb
 - lib/spectre/diagnostic.rb
@@ -62,17 +63,15 @@ files:
 - lib/spectre/logger/file.rb
 - lib/spectre/mixin.rb
 - lib/spectre/reporter/console.rb
-- lib/spectre/reporter/junit.rb
 - lib/spectre/resources.rb
 homepage: https://github.com/ionos-spectre/spectre-core
 licenses:
 - GPL-3.0-or-later
 metadata:
-  allowed_push_host: https://rubygems.org/
   homepage_uri: https://github.com/ionos-spectre/spectre-core
   source_code_uri: https://github.com/ionos-spectre/spectre-core
   changelog_uri: https://github.com/ionos-spectre/spectre-core/blob/master/CHANGELOG.md
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -80,15 +79,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
-signing_key:
+rubygems_version: 3.3.7
+signing_key: 
 specification_version: 4
 summary: Describe and run automated tests
 test_files: []

data/lib/spectre/reporter/junit.rb

@@ -1,102 +0,0 @@
-require 'CGI'
-
-# https://llg.cubic.org/docs/junit/
-# Azure mappings: https://docs.microsoft.com/en-us/azure/devops/pipelines/tasks/test/publish-test-results?view=azure-devops&tabs=junit%2Cyaml
-
-module Spectre::Reporter
-  class JUnit
-    def initialize config
-      @config = config
-    end
-
-    def report run_infos
-      now = Time.now.getutc
-      timestamp = now.strftime('%s')
-      datetime = now.strftime('%FT%T%:z')
-
-      xml_str = '<?xml version="1.0" encoding="UTF-8" ?>'
-      xml_str += '<testsuites>'
-
-      suite_id = 0
-
-      run_infos.group_by { |x| x.spec.subject }.each do |subject, run_infos|
-        failures = run_infos.select { |x| x.failure != nil }
-        errors = run_infos.select { |x| x.error != nil }
-        skipped = run_infos.select { |x| x.skipped? }
-
-        xml_str += '<testsuite package="' + CGI::escapeHTML(subject.desc) + '" id="' + CGI::escapeHTML(suite_id.to_s) + '" name="' + CGI::escapeHTML(subject.desc) + '" timestamp="' + datetime + '" tests="' + run_infos.count.to_s + '" failures="' + failures.count.to_s + '" errors="' + errors.count.to_s + '" skipped="' + skipped.count.to_s + '">'
-        suite_id += 1
-
-        run_infos.each do |run_info|
-          xml_str += '<testcase classname="' + CGI::escapeHTML(run_info.spec.file.to_s) + '" name="' + CGI::escapeHTML(run_info.spec.desc) + '" timestamp="' + run_info.started.to_s + '"  time="' + ('%.3f' % run_info.duration) + '">'
-
-          if run_info.failure and !run_info.failure.cause
-            failure_message = "Expected #{run_info.failure.expectation}"
-            failure_message += " with #{run_info.data}" if run_info.data
-
-            if run_info.failure.message
-              failure_message += " but it failed with #{run_info.failure.message}"
-            else
-              failure_message += " but it failed"
-            end
-
-            xml_str += '<failure message="' + CGI::escapeHTML(failure_message.gsub('"', '`')) + '"></failure>'
-          end
-
-
-          if run_info.error or (run_info.failure and run_info.failure.cause)
-            error = run_info.error || run_info.failure.cause
-
-            type = error.class.name
-            failure_message = error.message
-            text = error.backtrace.join "\n"
-
-            xml_str += '<error message="' + CGI::escapeHTML(failure_message.gsub('"', '`')) + '" type="' + type + '">'
-            xml_str += '<![CDATA[' + text + ']]>'
-            xml_str += '</error>'
-          end
-
-
-          if run_info.log.count > 0 or run_info.properties.count > 0 or run_info.data
-            xml_str += '<system-out>'
-            xml_str += '<![CDATA['
-
-            if run_info.properties.count > 0
-              run_info.properties.each do |key, val|
-                xml_str += "#{key}: #{val}\n"
-              end
-            end
-
-            if run_info.data
-              data_str = run_info.data
-              data_str = run_info.data.inspect unless run_info.data.is_a? String or run_info.data.is_a? Integer
-              xml_str += "data: #{data_str}\n"
-            end
-
-            if run_info.log.count > 0
-              messages = run_info.log.map { |x| "[#{x[0].strftime('%F %T')}] #{x[1]}" }
-              xml_str += messages.join("\n")
-            end
-
-            xml_str += ']]>'
-            xml_str += '</system-out>'
-          end
-
-          xml_str += '</testcase>'
-        end
-
-        xml_str += '</testsuite>'
-      end
-
-      xml_str += '</testsuites>'
-
-      Dir.mkdir @config['out_path'] unless Dir.exist? @config['out_path']
-
-      file_path = File.join(@config['out_path'], "spectre-junit_#{timestamp}.xml")
-
-      File.open(file_path, 'w') do |file|
-        file.write(xml_str)
-      end
-    end
-  end
-end