spectre-core 1.12.4 → 1.14.1

data/lib/spectre/assertion.rb

@@ -1,4 +1,5 @@
 require_relative '../spectre'
+require_relative '../spectre/helpers'
 
 require 'ostruct'
 require_relative 'logger'
@@ -7,38 +8,45 @@ require_relative 'logger'
 module Spectre
   module Assertion
     class ::Object
-      def should_be(val)
-        raise AssertionFailure.new("The value '#{self.to_s.trim}' should be '#{val.to_s.trim}'", val, self) unless self.to_s == val.to_s
+      def should_be(value)
+        evaluate(value, "#{self} should be #{value}") do |x|
+          self.to_s == x.to_s
+        end
       end
 
       def should_be_empty
-        raise AssertionFailure.new("The value '#{self.to_s.trim}' should be empty", nil, self) unless self.nil?
+        raise AssertionFailure.new("#{self.to_s.trim} should be empty", nil, self) unless self.nil?
       end
 
       def should_not_be(val)
-        raise AssertionFailure.new("The value '#{self.to_s.trim}' should not be '#{val.to_s.trim}'", val, self) unless self.to_s != val.to_s
+        raise AssertionFailure.new("#{self.to_s.trim} should not be #{val.to_s.trim}", val, self) unless self.to_s != val.to_s
       end
 
       def should_not_exist
-        raise AssertionFailure.new("The value '#{self.to_s.trim}' should not exist, but it does", val, self) unless self.to_s != nil
+        raise AssertionFailure.new("#{self.to_s.trim} should not exist, but it does", val, self) unless self.to_s != nil
       end
 
       def should_not_be_empty
-        raise AssertionFailure.new('The value is empty', 'nothing', self) unless self != nil
+        raise AssertionFailure.new('empty value', 'nothing', self) unless self != nil
+      end
+
+      def evaluate val, message, &block
+        val = Evaluation.new(val) unless val.is_a? Evaluation
+        raise AssertionFailure.new(message, val, self) unless val.run &block
       end
 
       def or other
-        OrEvaluation.new self, other
+        OrEvaluation.new(self, other)
       end
 
       def and other
-        AndEvaluation.new self, other
+        AndEvaluation.new(self, other)
       end
     end
 
     class ::NilClass
       def should_be(val)
-        raise AssertionFailure.new("There is nothing, but the value should be '#{val.to_s.trim}'", val, nil) unless val == nil
+        raise AssertionFailure.new("Value is empty, but it should be '#{val.to_s.trim}'", val, nil) unless val == nil
       end
 
       def should_be_empty
@@ -52,7 +60,7 @@ module Spectre
       end
 
       def should_not_be_empty
-        raise AssertionFailure.new('The value does not exist', 'nil')
+        raise AssertionFailure.new('Value is empty', 'nil')
       end
     end
 
@@ -66,21 +74,21 @@ module Spectre
       end
 
       def should_be_empty
-        raise AssertionFailure.new('The object should be empty', nil, self) unless self.empty?
+        raise AssertionFailure.new('Object should be empty', nil, self) unless self.empty?
       end
 
       def should_not_be_empty
-        raise AssertionFailure.new('The object should not be empty', nil, self) if self.empty?
+        raise AssertionFailure.new('Object should not be empty', nil, self) if self.empty?
       end
     end
 
     class ::OpenStruct
       def should_be_empty
-        raise AssertionFailure.new('The object should be empty', nil, self) unless self.to_h.empty?
+        raise AssertionFailure.new('Object should be empty', nil, self) unless self.to_h.empty?
       end
 
       def should_not_be_empty
-        raise AssertionFailure.new('The object should not be empty', nil, self) if self.to_h.empty?
+        raise AssertionFailure.new('Object should not be empty', nil, self) if self.to_h.empty?
       end
     end
 
@@ -93,7 +101,9 @@ module Spectre
           val = OpenStruct.new(val)
         end
 
-        raise AssertionFailure.new("The list [#{list.join(', ').trim}] should contain '#{val.to_s.trim}'", val, list) unless list.include? val
+        evaluate(val, "#{self} should contain #{val.to_s}") do |x|
+          self.include? x
+        end
       end
 
       def should_not_contain(val)
@@ -104,57 +114,61 @@ module Spectre
           val = OpenStruct.new(val)
         end
 
-        raise AssertionFailure.new("The list [#{list.join(', ').trim}] should not contain '#{val.to_s.trim}'", val, list) if list.include? val
+        raise AssertionFailure.new("[#{list.join(', ').trim}] should not contain '#{val.to_s.trim}'", val, list) if list.include? val
       end
 
       def should_be_empty
-        raise AssertionFailure.new('The list is not empty', self) unless self.empty?
+        raise AssertionFailure.new('List is not empty', self) unless self.empty?
       end
 
       def should_not_be_empty
-        raise AssertionFailure.new('The list is empty', self) if self.empty?
+        raise AssertionFailure.new('List is empty', self) if self.empty?
       end
     end
 
     class ::String
       def should_be(val)
-        raise AssertionFailure.new("The text '#{self.trim}' should be '#{val.to_s.trim}'", val, self) unless self == val
+        evaluate(val, "'#{self}' should be '#{val}'") do |x|
+          self.to_s == x.to_s
+        end
       end
 
       def should_be_empty
-        raise AssertionFailure.new("The text '#{self.trim}' should be empty", nil, self) unless self.empty?
+        raise AssertionFailure.new("'#{self.trim}' should be empty", nil, self) unless self.empty?
       end
 
       def should_not_be(val)
-        raise AssertionFailure.new("The text '#{self.trim}' should not be '#{val.to_s.trim}'", val, self) unless self != val
+        evaluate(value, "'#{self}' should not be '#{value}'") do |x|
+          self.to_s != x.to_s
+        end
       end
 
       def should_not_be_empty
-        raise AssertionFailure.new('The text should not be empty', 'nothing', self) unless not self.empty?
+        raise AssertionFailure.new('Text should not be empty', 'nothing', self) unless not self.empty?
       end
 
-      def should_contain(value)
-        raise AssertionFailure.new("The value is nil") if value.nil?
-
-        predicate = proc { |x| self.include? x.to_s }
-        evaluation = SingleEvaluation.new(value)
-        success = evaluation.call(predicate)
-
-        return if success
-
-        raise AssertionFailure.new("The text '#{self.to_s.trim}' should contain #{evaluation.to_s}", evaluation, self)
+      def should_contain(val)
+        evaluate(val, "'#{self.trim}' should contain '#{val.to_s}'") do |x|
+          self.include? x.to_s
+        end
       end
 
       def should_not_contain(val)
-        raise AssertionFailure.new("The text '#{self.trim}' should not contain '#{val.trim}'", val, self) if self.include? val
+        evaluate(val, "'#{self}' should not contain '#{val}'") do |x|
+          not self.include? x.to_s
+        end
       end
 
       def should_match(regex)
-        raise AssertionFailure.new("The text '#{self.trim}' should match '#{val}'", regex, self) unless self.match(regex)
+        evaluate(regex, "'#{self.trim}' should match /#{regex}/") do |x|
+          self.match(x)
+        end
       end
 
       def should_not_match(regex)
-        raise AssertionFailure.new("The text '#{self.trim}' should not match '#{val}'", regex, self) if self.match(regex)
+        evaluate(regex, "'#{self.trim}' should not match '#{regex}'") do |x|
+          not self.match(x)
+        end
       end
 
       alias :| :or
@@ -162,62 +176,58 @@ module Spectre
     end
 
     class Evaluation
-      def initialize value, other
-        @value = value
-        @other = other
+      def initialize val
+        @val = val
+      end
+
+      def run &block
+        evaluate(@val, block)
       end
 
-      def eval_assertion predicate, val
+      def evaluate(val, predicate)
         if val.is_a? Evaluation
-          val.call(predicate)
+          val.run &predicate
         else
           predicate.call(val)
         end
       end
 
-      alias :| :or
-      alias :& :and
-    end
-
-    class SingleEvaluation < Evaluation
-      def initialize value
-        super(value, nil)
-      end
-
-      def call predicate
-        eval_assertion(predicate, @value)
-      end
-
       def to_s
-        @value.to_s
+        @val.to_s
       end
     end
 
     class OrEvaluation < Evaluation
-      def initialize value, other
-        super(value, other)
+      def initialize val, other
+        @val = val
+        @other = other
       end
 
-      def call predicate
-        eval_assertion(predicate, @value) or eval_assertion(predicate, @other)
+      def run &block
+        res1 = evaluate(@val, block)
+        res2 = evaluate(@other, block)
+        res1 or res2
       end
 
       def to_s
-        "(#{@value.to_s} or #{@other.to_s})"
+        "(#{@val} or #{@other})"
       end
     end
 
     class AndEvaluation < Evaluation
-      def initialize value, other
-        super(value, other)
+      def initialize val, other
+        @val = val
+        @other = other
       end
 
-      def call predicate
-        eval_assertion(predicate, @value) and eval_assertion(predicate, @other)
+      def run &block
+        res1 = evaluate(@val, block)
+        res2 = evaluate(@other, block)
+        res1 and res2
       end
 
       def to_s
-        "(#{@value.to_s} and #{@other.to_s})"
+        "(#{@val} and #{@other})"
       end
     end
 
@@ -236,18 +246,26 @@ module Spectre
       @@success = nil
 
       def expect desc
+        status = 'unknown'
+
         begin
-          Logger.log_process("expect #{desc}")
+          Logging.log_process("expect #{desc}")
           yield
-          Logger.log_status(desc, Logger::Status::OK)
+          Logging.log_status(desc, Logging::Status::OK)
+          status = 'ok'
         rescue Interrupt => e
+          status = 'skipped'
           raise e
         rescue AssertionFailure => e
-          Logger.log_status(desc, Logger::Status::FAILED)
+          Logging.log_status(desc, Logging::Status::FAILED)
+          status = 'failed'
           raise AssertionFailure.new(e.message, e.expected, e.actual, desc), cause: nil
         rescue Exception => e
-          Logger.log_status(desc, Logger::Status::ERROR)
+          Logging.log_status(desc, Logging::Status::ERROR)
+          status = 'error'
           raise AssertionFailure.new("An unexpected error occurred during expectation: #{e.message}", nil, nil, desc), cause: e
+        ensure
+          Spectre::Runner.current.expectations.append([desc, status])
         end
       end
 
@@ -256,7 +274,7 @@ module Spectre
         prefix += " '#{desc}'" if desc
 
         begin
-          Logger.log_info(prefix) if desc
+          Logging.log_info(prefix) if desc
           yield
           @@success = true
           @@logger.info("#{prefix} finished with success")
@@ -281,7 +299,7 @@ module Spectre
     end
 
     Spectre.register do |config|
-      @@logger = ::Logger.new(config['log_file'], progname: 'spectre/assertion')
+      @@logger = Spectre::Logging::ModuleLogger.new(config, 'spectre/assertion')
       @@debug = config['debug']
     end
 

data/lib/spectre/async.rb

@@ -0,0 +1,31 @@
+require_relative '../spectre'
+
+Thread.abort_on_exception = true
+
+module Spectre
+  module Async
+    class << self
+      @@threads = {}
+
+      def async name='default', &block
+        unless @@threads.key? name
+          @@threads[name] = []
+        end
+
+        @@threads[name] << Thread.new(&block)
+      end
+
+      def await name='default'
+        return unless @@threads.key? name
+
+        threads = @@threads[name].map { |x| x.join() }
+
+        @@threads.delete(name)
+
+        threads.map { |x| x.value }
+      end
+    end
+
+    Spectre.delegate :async, :await, to: self
+  end
+end

data/lib/spectre/bag.rb

@@ -12,7 +12,7 @@ module Spectre
       end
     end
 
-    Spectre.register do |config|
+    Spectre.register do |_config|
       @@bag = OpenStruct.new
     end
 

data/lib/spectre/curl.rb

@@ -310,7 +310,7 @@ module Spectre::Curl
 
       start_time = Time.now
 
-      stdin, stdout, stderr, wait_thr = Open3.popen3(sys_cmd)
+      _, stdout, stderr, wait_thr = Open3.popen3(sys_cmd)
 
       end_time = Time.now
 
@@ -359,8 +359,8 @@ module Spectre::Curl
       end
 
       res_log = "[<] #{req_id} #{res[:code]} #{res[:message]} (#{end_time - start_time}s)\n"
-      res_headers.each do |header|
-        res_log += "#{header[0].to_s.ljust(30, '.')}: #{header[1].to_s}\n"
+      res_headers.each do |http_header|
+        res_log += "#{http_header[0].to_s.ljust(30, '.')}: #{http_header[1].to_s}\n"
       end
 
       if res[:body] != nil and not res[:body].empty?
@@ -380,11 +380,9 @@ module Spectre::Curl
   Spectre.register do |config|
     @@debug = config['debug']
 
-    @@logger = ::Logger.new(config['log_file'], progname: 'spectre/curl')
-    @@logger.level = @@debug ? Logger::DEBUG : Logger::INFO
+    @@logger = Spectre::Logging::ModuleLogger.new(config, 'spectre/curl')
 
     @@secure_keys = config['secure_keys'] || []
-
     @@curl_path = config['curl_path'] || 'curl'
 
     if config.key? 'http'

data/lib/spectre/helpers.rb

@@ -119,6 +119,10 @@ class ::Hash
 end
 
 class ::Array
+  def first_element
+    self[0]
+  end
+
   def last_element
     self[-1]
   end

data/lib/spectre/http/keystone.rb

@@ -42,8 +42,6 @@ module Spectre::Http
       net_req['X-Auth-Token'] = token
     end
 
-    private
-
     def self.authenticate keystone_url, username, password, project, domain, cert
       auth_data = {
         auth: {

data/lib/spectre/http.rb

@@ -19,7 +19,7 @@ module Spectre
       'cert' => nil,
       'headers' => nil,
       'query' => nil,
-      'content_type' => '',
+      'content_type' => nil,
       'timeout' => 180,
       'retries' => 0,
     }
@@ -27,9 +27,6 @@ module Spectre
     @@modules = []
 
     class HttpError < Exception
-      def initialize message
-        super message
-      end
     end
 
     class SpectreHttpRequest < Spectre::DslClass
@@ -80,8 +77,7 @@ module Spectre
         data = data.to_h if data.is_a? OpenStruct
         body JSON.pretty_generate(data)
 
-        # TODO: Only set content type, if not explicitly set
-        content_type('application/json')
+        content_type('application/json') unless @__req['content_type']
       end
 
       def body body_content
@@ -112,6 +108,10 @@ module Spectre
         @__req['use_ssl'] = true
       end
 
+      def no_log!
+        @__req['no_log'] = true
+      end
+
       def to_s
         @__req.to_s
       end
@@ -314,7 +314,14 @@ module Spectre
 
         req_log = "[>] #{req_id} #{req['method']} #{uri}\n"
         req_log += header_to_s(net_req)
-        req_log += try_format_json(req['body'], pretty: true) if req['body'] != nil and not req['body'].empty?
+
+        unless req['body'].nil? or req['body'].empty?
+          unless req['no_log']
+            req_log += try_format_json(req['body'], pretty: true)
+          else
+            req_log += '[...]'
+          end
+        end
 
         @@logger.info(req_log)
 
@@ -345,7 +352,14 @@ module Spectre
 
         res_log = "[<] #{req_id} #{net_res.code} #{net_res.message} (#{end_time - start_time}s)\n"
         res_log += header_to_s(net_res)
-        res_log += try_format_json(net_res.body, pretty: true) unless net_res.body.nil? or net_res.body.empty?
+
+        unless net_res.body.nil? or net_res.body.empty?
+          unless req['no_log']
+            res_log += try_format_json(net_res.body, pretty: true)
+          else
+            res_log += '[...]'
+          end
+        end
 
         @@logger.info(res_log)
 
@@ -361,7 +375,7 @@ module Spectre
     end
 
     Spectre.register do |config|
-      @@logger = ::Logger.new(config['log_file'], progname: 'spectre/http')
+      @@logger = Spectre::Logging::ModuleLogger.new(config, 'spectre/http')
       @@secure_keys = config['secure_keys'] || []
       @@debug = config['debug']
 

data/lib/spectre/logger/console.rb

@@ -1,7 +1,7 @@
 require 'ectoplasm'
 
 module Spectre
-  module Logger
+  module Logging
     class Console
       def initialize config
         raise 'No log format section in config for console logger' unless config.key? 'log_format' and config['log_format'].key? 'console'

data/lib/spectre/logger/file.rb

@@ -1,5 +1,5 @@
 module Spectre
-  module Logger
+  module Logging
     class File
       def initialize config
         raise 'No log format section in config for console logger' unless config.key? 'log_format' and config['log_format'].key? 'file'
@@ -9,77 +9,77 @@ module Spectre
         @fmt_end_group = @config['end_group']
         @fmt_sep = @config['separator']
 
-        @file_log = ::Logger.new config['log_file'], progname: 'spectre'
+        @file_log = ::Logger.new(config['log_file'], progname: 'spectre')
         @file_log.level = config['debug'] ? 'DEBUG' : 'INFO'
       end
 
       def start_subject subject
-        @file_log.debug "start running subject '#{subject.desc}'"
+        @file_log.debug("start running subject '#{subject.desc}'")
       end
 
       def end_subject subject
-        @file_log.debug "subject '#{subject.desc}' finished"
+        @file_log.debug("subject '#{subject.desc}' finished")
       end
 
       def start_context context
         if context and context.__desc
-          @file_log.debug "start running context '#{context.__desc}'"
+          @file_log.debug("start running context '#{context.__desc}'")
         else
-          @file_log.debug "start running main context of #{context.__subject.desc}"
+          @file_log.debug("start running main context of #{context.__subject.desc}")
         end
       end
 
       def end_context context
         if context and context.__desc
-          @file_log.debug "context '#{context.__desc}' finished"
+          @file_log.debug("context '#{context.__desc}' finished")
         else
-          @file_log.debug "main context finished of #{context.__subject.desc}"
+          @file_log.debug("main context finished of #{context.__subject.desc}")
         end
       end
 
       def start_spec spec, data=nil
         log_msg = "start running spec [#{spec.name}] '#{spec.desc}'"
         log_msg += " with data #{data}" if data
-        @file_log.debug log_msg
+        @file_log.debug(log_msg)
       end
 
       def end_spec spec, data=nil
         log_msg = "running spec [#{spec.name}] '#{spec.desc}'"
         log_msg += " with data #{data}" if data
         log_msg += " finished"
-        @file_log.debug log_msg
+        @file_log.debug(log_msg)
       end
 
       def log_separator desc
         desc = @fmt_sep.gsub('<desc>', desc) if @fmt_sep
-        @file_log.info desc
+        @file_log.info(desc)
       end
 
       def start_group desc
         desc = @fmt_start_group.gsub('<desc>', desc) if @fmt_start_group
-        @file_log.info desc
+        @file_log.info(desc)
       end
 
       def end_group desc
         desc = @fmt_end_group.gsub('<desc>', desc) if @fmt_end_group
-        @file_log.info desc
+        @file_log.info(desc)
       end
 
       def log_process desc
-        @file_log.debug desc
+        @file_log.debug(desc)
       end
 
       def log_info message
-        @file_log.info "#{Status::INFO} #{message}"
+        @file_log.info("#{Status::INFO} #{message}")
       end
 
       def log_debug message
-        @file_log.debug "#{Status::DEBUG} #{message}"
+        @file_log.debug("#{Status::DEBUG} #{message}")
       end
 
       def log_error spec, exception
         file, line = exception.backtrace[0].match(/(.*\.rb):(\d+)/).captures
-        @file_log.error "An unexpected error occurred at '#{file}:#{line}' while running spec '#{spec.name}': [#{exception.class}] #{exception.message}\n#{exception.backtrace.join "\n"}"
+        @file_log.error("An unexpected error occurred at '#{file}:#{line}' while running spec '#{spec.name}': [#{exception.class}] #{exception.message}\n#{exception.backtrace.join "\n"}")
       end
 
       def log_skipped spec, message=nil
@@ -89,13 +89,13 @@ module Spectre
           txt += ': ' + message
         end
 
-        @file_log.warn txt
+        @file_log.warn(txt)
       end
 
       def log_status desc, status, annotation=nil
         msg = "expected #{desc}...#{status.upcase}"
         msg += " - #{annotation}" if annotation
-        @file_log.debug msg
+        @file_log.debug(msg)
       end
     end
   end