spectre-core 1.12.2 → 1.13.0

data/lib/spectre/reporter/junit.rb

@@ -1,3 +1,5 @@
+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
 
@@ -7,38 +9,43 @@ module Spectre::Reporter
       @config = config
     end
 
+    def get_name run_info
+      run_name = "[#{run_info.spec.name}] #{run_info.spec.subject.desc}"
+      run_name += " - #{run_info.spec.context.__desc} -" unless run_info.spec.context.__desc.nil?
+      run_name += " #{run_info.spec.desc}"
+      run_name
+    end
+
     def report run_infos
       now = Time.now.getutc
       timestamp = now.strftime('%s')
-      datetime = now.strftime('%FT%T%:z')
+      datetime = now.strftime('%FT%T.%L')
 
       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? }
+      run_infos.group_by { |x| x.spec.subject }.each do |subject, info_group|
+        failures = info_group.select { |x| x.failure != nil }
+        errors = info_group.select { |x| x.error != nil }
+        skipped = info_group.select { |x| x.skipped? }
 
-        xml_str += '<testsuite package="' + subject.desc + '" id="' + suite_id.to_s + '" name="' + 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 + '">'
+        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}" failures="#{failures.count}" errors="#{errors.count}" skipped="#{skipped.count}">}
         suite_id += 1
 
-        run_infos.each do |run_info|
-          xml_str += '<testcase classname="' + run_info.spec.file.to_s + '" name="' + run_info.spec.desc + '" timestamp="' + run_info.started.to_s + '"  time="' + ('%.3f' % run_info.duration) + '">'
+        info_group.each do |run_info|
+          started = run_info.started.strftime('%FT%T.%L')
+
+          xml_str += %{<testcase classname="#{CGI::escapeHTML(run_info.spec.file.to_s)}" name="#{get_name(run_info)}" timestamp="#{started}"  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
+            failure_message += " but it failed"
+            failure_message += " with message: #{run_info.failure.message}" if run_info.failure.message
 
-            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="' + failure_message.gsub('"', '`') + '"></failure>'
+            xml_str += %{<failure message="#{CGI::escapeHTML(failure_message.gsub('"', '`'))}"></failure>}
           end
 
 
@@ -49,8 +56,8 @@ module Spectre::Reporter
             failure_message = error.message
             text = error.backtrace.join "\n"
 
-            xml_str += '<error message="' + failure_message.gsub('"', '`') + '" type="' + type + '">'
-            xml_str += '<![CDATA[' + text + ']]>'
+            xml_str += %{<error message="#{CGI::escapeHTML(failure_message.gsub('"', '`'))}" type="#{type}">}
+            xml_str += "<![CDATA[#{text}]]>"
             xml_str += '</error>'
           end
 
@@ -67,7 +74,7 @@ module Spectre::Reporter
 
             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
+              data_str = run_info.data.to_json unless run_info.data.is_a? String or run_info.data.is_a? Integer
               xml_str += "data: #{data_str}\n"
             end
 
@@ -92,9 +99,7 @@ module Spectre::Reporter
 
       file_path = File.join(@config['out_path'], "spectre-junit_#{timestamp}.xml")
 
-      File.open(file_path, 'w') do |file|
-        file.write(xml_str)
-      end
+      File.write(file_path, xml_str)
     end
   end
 end

data/lib/spectre/reporter/vstest.rb

@@ -0,0 +1,167 @@
+require 'cgi'
+require 'socket'
+require 'securerandom'
+
+# Azure mappings: https://docs.microsoft.com/en-us/azure/devops/pipelines/tasks/test/publish-test-results?view=azure-devops&tabs=trx%2Cyaml
+
+module Spectre::Reporter
+  class VSTest
+    def initialize config
+      @config = config
+      @date_format = '%FT%T.%L'
+    end
+
+    def report run_infos
+      now = Time.now.getutc
+
+      xml_str = '<?xml version="1.0" encoding="UTF-8" ?>'
+      xml_str += %{<TestRun xmlns="http://microsoft.com/schemas/VisualStudio/TeamTest/2010">}
+
+      started = run_infos[0].started
+      finished = run_infos[-1].finished
+
+      computer_name = Socket.gethostname
+
+      xml_str += %{<Times start="#{started.strftime(@date_format)}" finish="#{finished.strftime(@date_format)}" />}
+
+
+      # Write summary with file attachments
+      xml_str += '<ResultSummary>'
+      xml_str += '<ResultFiles>'
+      xml_str += %{<ResultFile path="#{File.absolute_path(@config['log_file'])}"></ResultFile>} if File.exists? @config['log_file']
+
+      report_files = Dir[File.join(@config['out_path'], '*')]
+
+      if report_files.any?
+        report_files.each do |report_file|
+          xml_str += %{<ResultFile path="#{File.absolute_path(report_file)}"></ResultFile>}
+        end
+      end
+
+      xml_str += '</ResultFiles>'
+      xml_str += '</ResultSummary>'
+
+
+      # Write test definitions
+      test_definitions = run_infos
+        .sort_by { |x| x.spec.name }
+        .map { |x| [SecureRandom.uuid(), SecureRandom.uuid(), x] }
+
+      xml_str += '<TestDefinitions>'
+      test_definitions.each do |test_id, execution_id, run_info|
+        xml_str += %{<UnitTest name="#{CGI::escapeHTML get_name(run_info)}" storage="#{CGI::escapeHTML(run_info.spec.file.to_s)}" id="#{test_id}">}
+        xml_str += %{<Execution id="#{execution_id}" />}
+        xml_str += '</UnitTest>'
+      end
+      xml_str += '</TestDefinitions>'
+
+
+      # Write test results
+      xml_str += '<Results>'
+      test_definitions.each do |test_id, execution_id, run_info|
+        duration_str = Time.at(run_info.duration).gmtime.strftime('%T.%L')
+
+        if run_info.failed?
+          outcome = 'Failed'
+        elsif run_info.error?
+          outcome = 'Error'
+        elsif run_info.skipped?
+          outcome = 'Skipped'
+        else
+          outcome = 'Passed'
+        end
+
+        xml_str += %{<UnitTestResult executionId="#{execution_id}" testId="#{test_id}" testName="#{CGI::escapeHTML get_name(run_info)}" computerName="#{computer_name}" duration="#{duration_str}" startTime="#{run_info.started.strftime(@date_format)}" endTime="#{run_info.finished.strftime(@date_format)}" outcome="#{outcome}">}
+
+        if run_info.log.any? or run_info.failed? or run_info.error?
+          xml_str += '<Output>'
+
+          # Write log entries
+          xml_str += '<StdOut>'
+          log_str = ''
+
+          if run_info.properties.count > 0
+            run_info.properties.each do |key, val|
+              log_str += "#{key}: #{val}\n"
+            end
+          end
+
+          if run_info.data
+            data_str = run_info.data
+            data_str = run_info.data.to_json unless run_info.data.is_a? String or run_info.data.is_a? Integer
+            log_str += "data: #{data_str}\n"
+          end
+
+          run_info.log.each do |timestamp, message, level, name|
+            log_str += %{#{timestamp.strftime(@date_format)} #{level.to_s.upcase} -- #{name}: #{CGI::escapeHTML(message.to_s)}\n}
+          end
+
+          xml_str += log_str
+          xml_str += '</StdOut>'
+
+          # Write error information
+          if run_info.failed? or run_info.error?
+            xml_str += '<ErrorInfo>'
+
+            if run_info.failed? and not run_info.failure.cause
+              xml_str += '<Message>'
+
+              failure_message = "Expected #{run_info.failure.expectation}"
+              failure_message += " with #{run_info.data}" if run_info.data
+              failure_message += " but it failed"
+              failure_message += " with message: #{run_info.failure.message}" if run_info.failure.message
+
+              xml_str += CGI::escapeHTML(failure_message)
+
+              xml_str += '</Message>'
+            end
+
+            if run_info.error or (run_info.failed? and run_info.failure.cause)
+              error = run_info.error || run_info.failure.cause
+
+              failure_message = error.message
+
+              xml_str += '<Message>'
+              xml_str += CGI::escapeHTML(failure_message)
+              xml_str += '</Message>'
+
+              stack_trace = error.backtrace.join "\n"
+
+              xml_str += '<StackTrace>'
+              xml_str += CGI::escapeHTML(stack_trace)
+              xml_str += '</StackTrace>'
+            end
+
+            xml_str += '</ErrorInfo>'
+          end
+
+          xml_str += '</Output>'
+        end
+
+
+        xml_str += '</UnitTestResult>'
+      end
+      xml_str += '</Results>'
+
+
+      # End report
+      xml_str += '</TestRun>'
+
+
+      Dir.mkdir(@config['out_path']) unless Dir.exists? @config['out_path']
+
+      file_path = File.join(@config['out_path'], "spectre-vstest_#{now.strftime('%s')}.trx")
+
+      File.write(file_path, xml_str)
+    end
+
+    private
+
+    def get_name run_info
+      run_name = "[#{run_info.spec.name}] #{run_info.spec.subject.desc}"
+      run_name += " - #{run_info.spec.context.__desc} -" unless run_info.spec.context.__desc.nil?
+      run_name += " #{run_info.spec.desc}"
+      run_name
+    end
+  end
+end

data/lib/spectre.rb

@@ -1,8 +1,8 @@
 module Spectre
   module Version
     MAJOR = 1
-    MINOR = 12
-    TINY  = 2
+    MINOR = 13
+    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