spectre-core 1.8.0

data/lib/spectre.rb

@@ -0,0 +1,434 @@
+module Spectre
+  module Version
+    MAJOR = 1
+    MINOR = 8
+    TINY  = 0
+  end
+
+  VERSION = [Version::MAJOR, Version::MINOR, Version::TINY].compact * '.'
+
+
+  ###########################################
+  # Custom Exceptions
+  ###########################################
+
+
+  class ExpectationFailure < Exception
+    attr_reader :expectation
+
+    def initialize message, expectation
+      super message
+      @expectation = expectation
+    end
+  end
+
+
+  ###########################################
+  # Internal Classes
+  ###########################################
+
+
+  # https://www.dan-manges.com/blog/ruby-dsls-instance-eval-with-delegation
+  class DslClass
+    def _evaluate &block
+      @__bound_self__ = eval 'self', block.binding
+      instance_eval(&block)
+    end
+
+    def _execute args, &block
+      @__bound_self__ = eval 'self', block.binding
+      instance_exec(args, &block)
+    end
+
+    def method_missing method, *args, **kwargs, &block
+      if @__bound_self__.respond_to? method
+        @__bound_self__.send method, *args, **kwargs, &block
+      else
+        Delegator.redirect method, *args, **kwargs, &block
+      end
+    end
+  end
+
+
+  class Subject
+    attr_reader :name, :desc, :specs
+
+    def initialize desc
+      @desc = desc
+      @specs = []
+      @name = desc.downcase.gsub(/[^a-z0-9]+/, '_')
+    end
+
+    def add_spec desc, tags, data, block, context, file
+      name = @name + '-' + (@specs.length+1).to_s
+      @specs << Spec.new(name, self, desc, tags, data, block, context, file)
+    end
+  end
+
+
+  class Spec
+    attr_reader :name, :subject, :context, :desc, :tags, :data, :block, :file
+
+    def initialize name, subject, desc, tags, data, block, context, file
+      @name = name
+      @context = context
+      @data = data
+      @subject = subject
+      @desc = desc
+      @tags = tags
+      @block = block
+      @file = file
+    end
+
+    def full_desc
+      @subject.desc + ' ' + desc
+    end
+  end
+
+
+  class RunInfo
+    attr_accessor :spec, :data, :started, :finished, :error, :failure, :skipped, :log, :properties
+
+    def initialize spec, data=nil
+      @spec = spec
+      @data = data
+      @started = nil
+      @finished = nil
+      @error = nil
+      @failure = nil
+      @skipped = false
+      @log = []
+      @properties = {}
+    end
+
+    def duration
+      @finished - @started
+    end
+
+    def skipped?
+      @skipped
+    end
+
+    def failed?
+      @error != nil
+    end
+  end
+
+
+  class Runner
+    @@current
+
+    def self.current
+      @@current
+    end
+
+    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)
+            end
+          end
+        end
+      end
+
+      runs
+    end
+
+    private
+
+    def run_context context, specs
+      runs = []
+
+      if context.__setup_blocks.count > 0
+        setup_run = run_blocks('setup', context, context.__setup_blocks)
+        runs << setup_run
+        return runs if setup_run.error or setup_run.failure
+      end
+
+      begin
+        specs.each do |spec|
+          if spec.data.length > 0
+            spec.data.each do |data|
+              Logger.log_spec(spec, data) do
+                runs << run_spec(spec, data)
+              end
+            end
+          else
+            Logger.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)
+        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
+
+      @@current = run_info
+
+      run_info.started = Time.now
+
+      Logger.log_context ctx do
+        begin
+          blocks.each do |block|
+            block.call
+          end
+
+          run_info.finished = Time.now
+
+        rescue ExpectationFailure => e
+          run_info.failure = e
+
+        rescue Exception => e
+          run_info.error = e
+          Logger.log_error spec, e
+
+        end
+      end
+
+      run_info.finished = Time.now
+
+      @@current = nil
+
+      run_info
+    end
+
+    def run_spec spec, data=nil
+      run_info = RunInfo.new spec, data
+
+      @@current = run_info
+
+      run_info.started = Time.now
+
+      begin
+        if spec.context.__before_blocks.count > 0
+          before_ctx = SpecContext.new spec.subject, 'before'
+
+          Logger.log_context before_ctx do
+            spec.context.__before_blocks.each do |block|
+              block.call data
+            end
+          end
+        end
+
+        spec.block.call data
+
+      rescue ExpectationFailure => e
+        run_info.failure = e
+
+      rescue Interrupt
+        run_info.skipped = true
+        Logger.log_skipped spec
+
+      rescue Exception => e
+        run_info.error = e
+        Logger.log_error spec, e
+
+      ensure
+        if spec.context.__after_blocks.count > 0
+          after_ctx = SpecContext.new spec.subject, 'after'
+
+          Logger.log_context after_ctx do
+            begin
+              spec.context.__after_blocks.each do |block|
+                block.call
+              end
+
+              run_info.finished = Time.now
+
+            rescue ExpectationFailure => e
+              run_info.failure = e
+
+            rescue Exception => e
+              run_info.error = e
+              Logger.log_error spec, e
+
+            end
+          end
+        end
+      end
+
+      run_info.finished = Time.now
+
+      @@current = nil
+
+      run_info
+    end
+  end
+
+
+  ###########################################
+  # DSL Classes
+  ###########################################
+
+
+  class SpecContext < DslClass
+    attr_reader :__subject, :__desc, :__before_blocks, :__after_blocks, :__setup_blocks, :__teardown_blocks
+
+    def initialize subject, desc=nil
+      @__subject = subject
+      @__desc = desc
+
+      @__before_blocks = []
+      @__after_blocks = []
+      @__setup_blocks = []
+      @__teardown_blocks = []
+    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
+
+      @__subject.add_spec(desc, tags, with, block, self, spec_file)
+    end
+
+    def before &block
+      @__before_blocks << block
+    end
+
+    def after &block
+      @__after_blocks << block
+    end
+
+    def setup &block
+      @__setup_blocks << block
+    end
+
+    def teardown &block
+      @__teardown_blocks << block
+    end
+
+    def context desc=nil, &block
+      ctx = SpecContext.new(@__subject, desc)
+      ctx._evaluate &block
+    end
+  end
+
+
+  ###########################################
+  # Core Modules
+  ###########################################
+
+
+  module Delegator
+    @@mappings = {}
+
+    def self.delegate(*methods, target)
+      methods.each do |method_name|
+        define_method(method_name) do |*args, &block|
+          return super(*args, &block) if respond_to? method_name
+          target.send(method_name, *args, &block)
+        end
+
+        @@mappings[method_name] = target
+
+        private method_name
+      end
+    end
+
+    def self.redirect method_name, *args, **kwargs, &block
+      target = @@mappings[method_name]
+      raise "No method or variable '#{method_name}' defined" if !target
+      target.send(method_name, *args, **kwargs, &block)
+    end
+  end
+
+
+  class << self
+    @@subjects = []
+    @@modules = []
+
+    attr_reader :file_log, :logger
+
+
+    def specs spec_filter=[], tags=[]
+      @@subjects
+        .map { |x| x.specs }
+        .flatten
+        .select do |spec|
+          (spec_filter.empty? or spec_filter.any? { |x| spec.name.match('^' + x.gsub('*', '.*') + '$') }) and (tags.empty? or tags.any? { |x| has_tag(spec.tags, x) })
+        end
+    end
+
+
+    def has_tag tags, tag_exp
+      tags = tags.map { |x| x.to_s }
+      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
+    end
+
+
+    def register &block
+      @@modules << block
+    end
+
+
+    def configure config
+      @@modules.each do |block|
+        block.call(config)
+      end
+    end
+
+
+    ###########################################
+    # Global Functions
+    ###########################################
+
+
+    def describe desc, &block
+      subject = @@subjects.find { |x| x.desc == desc }
+
+      if !subject
+        subject = Subject.new(desc)
+        @@subjects << subject
+      end
+
+      ctx = SpecContext.new(subject)
+      ctx._evaluate &block
+    end
+
+    def property key, val
+      Spectre::Runner.current.properties[key] = val
+    end
+
+  end
+
+  delegate :describe, :property, to: Spectre
+end
+
+
+extend Spectre::Delegator

data/lib/spectre/assertion.rb

@@ -0,0 +1,277 @@
+require 'ostruct'
+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
+      end
+
+      def should_be_empty
+        raise AssertionFailure.new("The value '#{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
+      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
+      end
+
+      def should_not_be_empty
+        raise AssertionFailure.new('The value should not be empty', 'nothing', self) unless self != nil
+      end
+
+      def or other
+        OrEvaluation.new self, other
+      end
+
+      def and 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
+      end
+
+      def should_be_empty
+      end
+
+      def should_not_be(val)
+        raise AssertionFailure.new(val, 'nil') unless val != nil
+      end
+
+      def should_not_exist
+      end
+
+      def should_not_be_empty
+        raise AssertionFailure.new('not empty', 'nil')
+      end
+    end
+
+
+    class ::Hash
+      def should_contain(other)
+        raise AssertionFailure.new(other, self) unless self.merge(other) == self
+      end
+
+      def should_not_contain(other)
+        raise AssertionFailure.new(other, self) unless self.merge(other) != self
+      end
+    end
+
+
+    class ::Array
+      def should_contain(val)
+        list = self
+
+        if val.is_a? Hash and self.all? { |x| x.is_a? OpenStruct or x.is_a? Hash }
+          list = self.map { |x| OpenStruct.new(x) }
+          val = OpenStruct.new(val)
+        end
+
+        raise AssertionFailure.new("The list [#{list.join(', ').trim}] should contain '#{val.trim}'", val, list) unless list.include? val
+      end
+
+      def should_not_contain(val)
+        list = self
+
+        if val.is_a? Hash and self.all? { |x| x.is_a? OpenStruct or x.is_a? Hash }
+          list = self.map { |x| OpenStruct.new(x) }
+          val = OpenStruct.new(val)
+        end
+
+        raise AssertionFailure.new("The list [#{list.join(', ').trim}] should not contain '#{val.trim}'", val, list) if list.include? val
+      end
+
+      def should_be_empty
+        raise AssertionFailure.new('empty list', self) unless self.length == 0
+      end
+
+      def should_not_be_empty
+        raise AssertionFailure.new('no empty list', self) unless self.length > 0
+      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
+      end
+
+      def should_be_empty
+        raise AssertionFailure.new("The text '#{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
+      end
+
+      def should_not_be_empty
+        raise AssertionFailure.new('The text should not be empty', 'nothing', self) unless not self.empty?
+      end
+
+      def should_contain(value)
+        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)
+      end
+
+      def should_not_contain(val)
+        raise AssertionFailure.new("The text '#{self.trim}' should not contain '#{val.trim}'", val, self) if self.include? val
+      end
+
+      def should_match(regex)
+        raise AssertionFailure.new("The text '#{self.trim}' should match '#{val}'", regex, self) unless self.match(regex)
+      end
+
+      def should_not_match(regex)
+        raise AssertionFailure.new("The text '#{self.trim}' should not match '#{val}'", regex, self) if self.match(regex)
+      end
+
+      alias :| :or
+      alias :& :and
+    end
+
+
+    class Evaluation
+      def initialize value, other
+        @value = value
+        @other = other
+      end
+
+      def eval_assertion predicate, val
+        if val.is_a? Evaluation
+          val.call(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
+      end
+    end
+
+
+    class OrEvaluation < Evaluation
+      def initialize value, other
+        super value, other
+      end
+
+      def call predicate
+        eval_assertion(predicate, @value) or eval_assertion(predicate, @other)
+      end
+
+      def to_s
+        "(#{@value.to_s} or #{@other.to_s})"
+      end
+    end
+
+
+    class AndEvaluation < Evaluation
+      def initialize value, other
+        super value, other
+      end
+
+      def call predicate
+        eval_assertion(predicate, @value) and eval_assertion(predicate, @other)
+      end
+
+      def to_s
+        "(#{@value.to_s} and #{@other.to_s})"
+      end
+    end
+
+
+    class AssertionFailure < ExpectationFailure
+      attr_reader :expected, :actual
+
+      def initialize message, expected=nil, actual=nil, expectation=nil
+        super message, expectation
+        @expected = expected
+        @actual = actual
+      end
+    end
+
+
+    class << self
+      @@success = nil
+
+      def eval_assertion predicate, val
+        if val.is_a? Proc
+          val.call(predicate)
+        else
+          predicate.call(val)
+        end
+      end
+
+      def expect desc
+        begin
+          Logger.log_process("expect #{desc}")
+          yield
+          Logger.log_status(desc, Logger::Status::OK)
+
+        rescue Interrupt => e
+          raise e
+
+        rescue AssertionFailure => e
+          Logger.log_status(desc, Logger::Status::FAILED)
+          raise AssertionFailure.new(e.message, e.expected, e.actual, desc), cause: nil
+
+        rescue Exception => e
+          Logger.log_status(desc, Logger::Status::ERROR)
+          raise AssertionFailure.new("An unexpected error occured during expectation: #{e.message}", nil, nil, desc), cause: e
+        end
+      end
+
+      def observe desc = nil
+        begin
+          Logger.log_info("observing #{desc}") if desc
+          yield
+          @@success = true
+
+        rescue Interrupt => e
+          raise e
+
+        rescue Exception => e
+          @@success = false
+        end
+      end
+
+      def success?
+        @@success
+      end
+
+      def fail_with message
+        raise AssertionFailure.new(message)
+      end
+    end
+
+    Spectre.delegate :expect, :observe, :success?, :fail_with, to: self
+  end
+end