spectre-core 1.8.0

data/lib/spectre/mixin.rb

@@ -0,0 +1,41 @@
+require 'ostruct'
+
+module Spectre
+  module Mixin
+    class << self
+      @@mixins = {}
+
+      def mixin desc, &block
+        @@mixins[desc] = block
+      end
+
+      def run desc, with: []
+        raise "no mixin with desc '#{desc}' defined" unless @@mixins.has_key? desc
+        Logger.log_debug "running mixin '#{desc}'"
+
+        if with.is_a? Array
+          @@mixins[desc].call *with
+        else
+          @@mixins[desc].call with
+        end
+      end
+
+      alias_method :also, :run
+      alias_method :step, :run
+    end
+
+    Spectre.register do |config|
+      if not config.has_key? 'mixin_patterns'
+        return
+      end
+
+      config['mixin_patterns'].each do |pattern|
+        Dir.glob(pattern).each do|f|
+          require_relative File.join(Dir.pwd, f)
+        end
+      end
+    end
+
+    Spectre.delegate :mixin, :run, :also, :step, to: Mixin
+  end
+end

data/lib/spectre/mysql.rb

@@ -0,0 +1,97 @@
+require 'mysql2'
+
+module Spectre
+  module MySQL
+
+    class MySqlQuery < DslClass
+      def initialize query
+        @__query = query
+      end
+
+      def host hostname
+        @__query['host'] = hostname
+      end
+
+      def username user
+        @__query['username'] = user
+      end
+
+      def password pass
+        @__query['password'] = pass
+      end
+
+      def database name
+        @__query['database'] = name
+      end
+
+      def query statement
+        @__query['query'] = [] if not @__query.has_key? 'query'
+        @__query['query'].append(statement)
+      end
+    end
+
+    class << self
+      @@mysql_cfg = {}
+      @@result = nil
+      @@last_conn = nil
+
+      def mysql name = nil, &block
+        query = {}
+
+        if name != nil and @@mysql_cfg.has_key? name
+          query.merge! @@mysql_cfg[name]
+          raise "No `host' set for MySQL client '#{name}'. Check your MySQL config in your environment." if !query['host']
+        elsif name != nil
+          query['host'] = name
+        elsif @@last_conn == nil
+          raise 'No name given and there was no previous MySQL connection to use'
+        end
+
+        MySqlQuery.new(query).instance_eval(&block) if block_given?
+
+        if name != nil
+          @@last_conn = {
+            host: query['host'],
+            username: query['username'],
+            password: query['password'],
+            database: query['database']
+          }
+        end
+
+        @@logger.info "Connecting to database #{query['username']}@#{query['host']}:#{query['database']}"
+
+        client = ::Mysql2::Client.new(**@@last_conn)
+
+        res = []
+
+        query['query'].each do |statement|
+          @@logger.info 'Executing statement "' + statement + '"'
+          res = client.query(statement, cast_booleans: true)
+        end if query['query']
+
+        @@result = res.map { |row| OpenStruct.new row } if res
+
+        client.close
+      end
+
+      def result
+        raise 'No MySQL query has been executed yet' unless @@result
+        @@result
+      end
+    end
+
+    Spectre.register do |config|
+      @@logger = ::Logger.new config['log_file'], progname: 'spectre/mysql'
+
+      if config.has_key? 'mysql'
+        @@mysql_cfg = {}
+
+        config['mysql'].each do |name, cfg|
+          @@mysql_cfg[name] = cfg
+        end
+      end
+    end
+
+    Spectre.delegate :mysql, :result, to: self
+  end
+end

data/lib/spectre/reporter/console.rb

@@ -0,0 +1,103 @@
+module Spectre::Reporter
+  class Console
+    def initialize config
+      @config = config
+    end
+
+    def report run_infos
+
+      report_str = ''
+
+      errors = 0
+      failures = 0
+      skipped = run_infos.select { |x| x.skipped? }.count
+
+      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"
+
+        if run_info.failure
+          report_str += "     Expected #{run_info.failure.expectation}"
+          report_str += " with #{run_info.data}" if run_info.data
+          report_str += " during #{spec.context.__desc}" if spec.context.__desc
+
+          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)
+
+          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 += "     but an unexpected error occured during run\n"
+          report_str += format_exception(run_info.error)
+          errors += 1
+        end
+      end
+
+      if failures + errors > 0
+        summary = ''
+        summary += "#{run_infos.length - failures - errors - skipped} succeeded "
+        summary += "#{failures} failures " if failures > 0
+        summary += "#{errors} errors " if errors > 0
+        summary += "#{skipped} skipped " if skipped > 0
+        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
+      end
+
+      puts report_str.red
+    end
+
+    private
+
+    def format_title run_info
+      title = run_info.spec.subject.desc
+      title += ' ' + run_info.spec.desc
+      title += " (#{'%.3f' % run_info.duration}s)"
+      title += " [#{run_info.spec.name}]"
+      title
+    end
+
+    def format_exception error
+      non_spectre_files = error.backtrace.select { |x| !x.include? 'lib/spectre' }
+
+      if non_spectre_files.count > 0
+        causing_file = non_spectre_files.first
+      else
+        causing_file = error.backtrace[0]
+      end
+
+      matches = causing_file.match(/(.*\.rb):(\d+)/)
+
+      return '' unless matches
+
+      file, line = matches.captures
+      file.slice!(Dir.pwd + '/')
+
+      str = ''
+      str += "       file.....: #{file}\n"
+      str += "       line.....: #{line}\n"
+      str += "       type.....: #{error.class}\n"
+      str += "       message..: #{error.message}\n"
+      str
+    end
+  end
+end

data/lib/spectre/reporter/junit.rb

@@ -0,0 +1,98 @@
+# 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="' + 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 + '">'
+        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) + '">'
+
+          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="' + 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="' + 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>'
+
+            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 += '</system-out>'
+          end
+
+          xml_str += '</testcase>'
+        end
+
+        xml_str += '</testsuite>'
+      end
+
+      xml_str += '</testsuites>'
+
+      Dir.mkdir @config['out_path'] if not 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

data/lib/spectre/resources.rb

@@ -0,0 +1,46 @@
+require 'ostruct'
+
+module Spectre
+  module Resources
+    class ResourceCollection
+      def initialize
+        @items = {}
+      end
+
+      def add name, path
+        @items[name] = path
+      end
+
+      def [] name
+        raise "Resource with name '#{name}' does not exist" if not @items.has_key? name
+        @items[name]
+      end
+    end
+
+    class << self
+      @@resources = ResourceCollection.new
+
+      def resources
+        @@resources
+      end
+    end
+
+    Spectre.register do |config|
+      return if !config.has_key? 'resource_paths'
+
+      config['resource_paths'].each do |resource_path|
+        resource_files = Dir.glob File.join(resource_path, '**/*')
+
+        resource_files.each do |file|
+          file.slice! resource_path
+          file = file[1..-1]
+          @@resources.add file, File.expand_path(File.join resource_path, file)
+        end
+      end
+
+      @@resources.freeze
+    end
+
+    Spectre.delegate :resources, to: Resources
+  end
+end

data/lib/spectre/ssh.rb

@@ -0,0 +1,149 @@
+require 'net/ssh'
+require 'logger'
+
+
+module Spectre
+  module SSH
+    @@cfg = {}
+
+    class SSHConnection < DslClass
+      def initialize host, username, opts, logger
+        opts[:non_interactive] = true
+
+        @__logger = logger
+        @__host = host
+        @__username = username
+        @__opts = opts
+        @__session = nil
+        @__exit_code = nil
+        @__output = ''
+      end
+
+      def file_exists path
+        exec "ls #{path}"
+        exit_code == 0
+      end
+
+      def owner_of path
+        exec "stat -c %U #{path}"
+        output.chomp
+      end
+
+      def connect!
+        return unless @__session == nil or @__session.closed?
+        @__session = Net::SSH.start(@__host, @__username, @__opts)
+      end
+
+      def close
+        return unless @__session and not @__session.closed?
+        @__session.close
+      end
+
+      def can_connect?
+        @__output = nil
+
+        begin
+          connect!
+          @__session.open_channel.close
+          @__output = "successfully connected to #{@__host} with user #{@__username}"
+          @__exit_code = 0
+          return true
+        rescue Exception => e
+          @__logger.error e.message
+          @__output = "unable to connect to #{@__host} with user #{@__username}"
+          @__exit_code = 1
+        end
+
+        return false
+      end
+
+      def exec command
+        connect!
+
+        log_str = "#{@__session.options[:user]}@#{@__session.host} -p #{@__session.options[:port]} #{command}"
+
+        @channel = @__session.open_channel do |channel|
+          channel.exec(command) do |ch, success|
+            abort "could not execute #{command} on #{@__session.host}" unless success
+
+            @__output = ''
+
+            channel.on_data do |ch, data|
+              @__output += data
+            end
+
+            channel.on_extended_data do |ch,type,data|
+              @__output += data
+            end
+
+            channel.on_request('exit-status') do |ch, data|
+              @__exit_code = data.read_long
+            end
+
+            # channel.on_request('exit-signal') do |ch, data|
+            #   exit_code = data.read_long
+            # end
+          end
+
+        end
+
+        @channel.wait
+        @__session.loop
+
+        log_str += "\n" + @__output
+        @__logger.info log_str
+      end
+
+      def output
+        @__output
+      end
+
+      def exit_code
+        @__exit_code
+      end
+    end
+
+
+    class << self
+      def ssh name, config = {}, &block
+        raise "SSH connection '#{name}' not configured" unless @@cfg.has_key?(name) or config.count > 0
+
+        cfg = @@cfg[name] || {}
+
+        host = cfg['host'] || name
+        username = config[:username] || cfg['username']
+        password = config[:password] || cfg['password']
+
+        opts = {}
+        opts[:password] = password
+        opts[:port] = config[:port] || cfg['port'] || 22
+        opts[:keys] = [cfg['key']] if cfg.has_key? 'key'
+        opts[:passphrase] = cfg['passphrase'] if cfg.has_key? 'passphrase'
+
+        opts[:auth_methods] = []
+        opts[:auth_methods].push 'publickey' if opts[:keys]
+        opts[:auth_methods].push 'password' if opts[:password]
+
+        ssh_con = SSHConnection.new(host, username, opts, @@logger)
+
+        begin
+          ssh_con.instance_eval &block
+        ensure
+          ssh_con.close
+        end
+      end
+    end
+
+    Spectre.register do |config|
+      @@logger = ::Logger.new config['log_file'], progname: 'spectre/ssh'
+
+      if config.has_key? 'ssh'
+        config['ssh'].each do |name, cfg|
+          @@cfg[name] = cfg
+        end
+      end
+    end
+
+    Spectre.delegate :ssh, to: self
+  end
+end