calificador 0.1.0

data/lib/calificador/build/factory.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+using Calificador::Util::CoreExtensions
+
+module Calificador
+  module Build
+    # Factory calss
+    class Factory < AttributeContainer
+      # Configuration derived factories
+      class Dsl < AttributeContainer::Dsl
+        def trait(name, description = nil, &block)
+          factory = Build::Factory.new(
+            context: @delegate.context,
+            parent: @delegate,
+            key: @delegate.key.with(name),
+            name: [@delegate.name, name].compact.join("_"),
+            source_location: block.source_location,
+            description: description || __default_trait_description(trait: name)
+          )
+
+          factory.dsl_config(&block)
+          @delegate.context.add_factory(factory)
+        end
+
+        protected
+
+        def __default_trait_description(trait:)
+          trait.to_s.gsub("_", " ").chomp
+        end
+      end
+
+      attr_reader :key, :context, :name, :source_location
+      attr_accessor :init_with
+
+      def initialize(context:, parent: nil, key:, name:, description: nil, source_location:, values: nil)
+        super(parent: parent, description: description)
+
+        raise "Parent factory must have same type" unless parent.nil? || parent.key.type == key.type
+
+        @context = context
+        @key = key
+        @name = name.to_sym
+        @source_location = source_location
+        @values = values&.dup || {}
+      end
+
+      def create(context:)
+        evaluator = AttributeEvaluator.new(context: context)
+
+        collect_attributes_and_values(evaluator: evaluator)
+
+        before_create(evaluator: evaluator)
+
+        object = create_object(evaluator: evaluator)
+
+        set_properties(object: object, evaluator: evaluator)
+
+        after_create(evaluator: evaluator, object: object)
+
+        object
+      end
+
+      def add_values(values)
+        @values.merge!(values)
+      end
+
+      def setup(test_class:); end
+
+      protected
+
+      def collect_attributes_and_values(evaluator:)
+        @parent&.collect_attributes_and_values(evaluator: evaluator)
+        evaluator.add_attributes(@attributes.values)
+        evaluator.add_values(@values)
+      end
+
+      def before_create(evaluator:)
+        @parent&.before_create(evaluator: evaluator)
+        evaluator.evaluate(&@before_create) unless @before_create.nil?
+      end
+
+      def after_create(evaluator:, object:)
+        @parent&.after_create(evaluator: evaluator, object: object)
+        evaluator.evaluate(object, &@after_create) unless @after_create.nil?
+      end
+
+      def nearest_init_with
+        @init_with || @parent&.nearest_init_with
+      end
+
+      def create_object(evaluator:)
+        init_with = nearest_init_with
+
+        if init_with.nil?
+          call_initializer(evaluator: evaluator)
+        else
+          evaluator.evaluate(&init_with)
+        end
+      end
+
+      def set_properties(object:, evaluator:)
+        evaluator.attributes.each_value do |attribute|
+          object.send(:"#{attribute.name}=", evaluator.value(name: attribute.name)) if attribute.type == :property
+        end
+
+        evaluator.values.each do |name, value| # rubocop:disable Style/HashEachMethods
+          object.send(:"#{name}=", value) unless evaluator.attribute?(name: name)
+        end
+      end
+
+      def call_initializer(evaluator:)
+        parameters = []
+        options = {}
+
+        @key.type.instance_method(:initialize).parameters.each do |type, name|
+          case type
+          when :req
+            parameters << evaluator.value(name: name)
+          when :opt
+            parameters << evaluator.value(name: name) if evaluator.attribute?(name: name)
+          when :keyreq
+            options[name] = evaluator.value(name: name)
+          when :key
+            options[name] = evaluator.value(name: name) if evaluator.attribute?(name: name)
+          end
+        end
+
+        @key.type.new(*parameters, **options)
+      end
+    end
+  end
+end

data/lib/calificador/build/trait.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Calificador
+  module Build
+    # Trait description
+    class Trait < AttributeContainer
+      # Configuration proxy for traits
+      class Dsl < AttributeContainer::Dsl
+      end
+
+      attr_reader :name
+
+      def initialize(parent:, name:, description: nil)
+        super(parent: parent, description: description)
+
+        @name = name.to_sym
+      end
+    end
+  end
+end

data/lib/calificador/key.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "minitest"
+
+using Calificador::Util::CoreExtensions
+
+module Calificador
+  # Test subject key
+  class Key
+    DEFAULT_TRAIT = :"<default>"
+    INHERITED_TRAIT = :"<inherited>"
+
+    class << self
+      def [](type, trait = DEFAULT_TRAIT)
+        new(type: type, trait: trait)
+      end
+    end
+
+    attr_reader :type, :trait
+
+    def initialize(type:, trait: DEFAULT_TRAIT)
+      raise ArgumentError, "Illegal trait value #{trait}" if trait == INHERITED_TRAIT
+
+      @type = type
+      @trait = trait || DEFAULT_TRAIT
+    end
+
+    def hash
+      (@type.hash * 31) + @trait.hash
+    end
+
+    def ==(other)
+      (@type == other.type) && (@trait == other.trait)
+    end
+
+    alias_method :eql?, :==
+
+    def to_s
+      trait == DEFAULT_TRAIT ? type.to_s : "#{type} (#{trait})"
+    end
+
+    alias_method :inspect, :to_s
+
+    def with(trait)
+      case trait
+      when INHERITED_TRAIT
+        self
+      when nil, DEFAULT_TRAIT
+        @trait == DEFAULT_TRAIT ? self : Key.new(type: @type, trait: DEFAULT_TRAIT)
+      else
+        trait == @trait ? self : Key.new(type: @type, trait: trait)
+      end
+    end
+
+    def trait?
+      @trait != DEFAULT_TRAIT
+    end
+  end
+end

data/lib/calificador/minitest/minitest_patches.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "minitest/test"
+
+using Calificador::Util::CoreExtensions
+
+module Calificador
+  module Minitest
+    # Patches to minitest classes
+    module MinitestPatches
+      # Patches to Minitest::Assertion
+      module AssertionMethods
+        def location
+          last_before_assertion = ""
+
+          backtrace.reverse_each do |s|
+            break if s =~ %r{assertor|in .(assert|refute|flunk|pass|fail|raise|must|wont)}
+
+            last_before_assertion = s
+          end
+
+          last_before_assertion.sub(%r{:in .*$}, "")
+        end
+      end
+    end
+  end
+end

data/lib/calificador/spec/basic_context.rb

@@ -0,0 +1,353 @@
+# frozen_string_literal: true
+
+using Calificador::Util::CoreExtensions
+
+module Calificador
+  module Spec
+    class BasicContext
+      class Dsl
+        def initialize(delegate:)
+          @delegate = delegate
+        end
+
+        def factory(type, description = nil, name: nil, &block)
+          key = Key[type]
+          name ||= BasicContext.default_factory_name(test_class: @delegate.test_class, key: key)
+
+          factory = Build::Factory.new(
+            context: @delegate,
+            key: key,
+            name: name,
+            description: description,
+            source_location: block.source_location
+          )
+
+          factory.dsl_config(&block)
+          @delegate.add_factory(factory)
+        end
+
+        def examine(subject_type, description = nil, trait: Key::DEFAULT_TRAIT, **values, &block)
+          subject_key = Key[subject_type, trait == Key::INHERITED_TRAIT ? Key::DEFAULT_TRAIT : trait]
+          overrides = BasicContext.collect_overrides(values: values, default_key: subject_key)
+
+          description ||= BasicContext.default_examine_description(
+            test_class: @delegate.test_class,
+            subject_key: subject_key,
+            values: values
+          )
+
+          context = Spec::ExamineContext.new(
+            parent: @delegate,
+            subject_key: subject_key,
+            description: description,
+            overrides: overrides
+          )
+
+          context.dsl_config(&block)
+
+          @delegate.add_context(context, &block)
+        end
+
+        def method(method, description = nil, &block)
+          context = Spec::InstanceMethodContext.new(
+            parent: @delegate,
+            method: method,
+            description: description || "\##{method}"
+          )
+
+          context.dsl_config(&block)
+
+          @delegate.add_context(context, &block)
+        end
+
+        def class_method(method, description = nil, &block)
+          context = Spec::ClassMethodContext.new(
+            parent: @delegate,
+            method: method,
+            description: description || ".#{method}"
+          )
+
+          context.dsl_config(&block)
+
+          @delegate.add_context(context, &block)
+        end
+
+        def must(description, trait: Key::INHERITED_TRAIT, **values, &block)
+          subject_key = @delegate.subject_key.with(trait)
+          overrides = BasicContext.collect_overrides(values: values, default_key: subject_key)
+
+          context = Spec::TestMethod.new(
+            parent: @delegate,
+            subject_key: subject_key,
+            description: "must #{description}",
+            overrides: overrides,
+            expected_to_fail: false,
+            body: block
+          )
+
+          @delegate.add_context(context)
+        end
+
+        def must_fail(description, trait:, **values, &block)
+          subject_key = @delegate.subject_key.with(trait)
+          overrides = BasicContext.collect_overrides(values: values, default_key: subject_key)
+
+          context = Spec::TestMethod.new(
+            parent: @delegate,
+            subject_key: subject_key,
+            description: "must fail #{description}",
+            overrides: overrides,
+            expected_to_fail: true,
+            body: block
+          )
+
+          @delegate.add_context(context)
+        end
+
+        def with(description, trait: Key::INHERITED_TRAIT, **values, &block)
+          __condition(conjunction: "with", description: description, trait: trait, values: values, &block)
+        end
+
+        def without(description, trait: Key::INHERITED_TRAIT, **values, &block)
+          __condition(conjunction: "without", description: description, trait: trait, values: values, &block)
+        end
+
+        def where(description, trait: Key::INHERITED_TRAIT, **values, &block)
+          __condition(conjunction: "where", description: "description", trait: trait, values: values, &block)
+        end
+
+        protected
+
+        def __condition(conjunction:, description:, trait: Key::INHERITED_TRAIT, values: {}, &block)
+          if description.is_a?(Symbol) && trait == Key::INHERITED_TRAIT
+            trait = description
+            description = nil
+          end
+
+          subject_key = @delegate.subject_key.with(trait)
+          overrides = BasicContext.collect_overrides(values: values, default_key: subject_key)
+
+          description ||= __default_description(key: subject_key)
+
+          context = Spec::ConditionContext.new(
+            parent: @delegate,
+            subject_key: subject_key,
+            description: description,
+            overrides: overrides
+          )
+
+          context.dsl_config(&block)
+
+          @delegate.add_context(context, &block)
+        end
+
+        def __default_description(key:)
+          raise "Please provide a description or a trait" if key.trait == Key::INHERITED_TRAIT
+
+          factory = @delegate.lookup_factory(key: key)
+
+          raise "No factory defined for #{key}" if factory.nil?
+
+          factory.description
+        end
+      end
+
+      class << self
+        def default_factory_name(test_class:, key:)
+          name = key.type.name.delete_prefix(test_class.parent_prefix).gsub("::", "").snake_case
+
+          name = "#{name}_#{key.trait}" if key.trait?
+
+          name.to_sym
+        end
+
+        def default_examine_description(test_class:, subject_key:, values:)
+          description = StringIO.new
+          description << subject_key.type.name.delete_prefix(test_class.parent_prefix)
+
+          description << " (" << subject_key.trait.to_s.gsub("_", " ") << ")" if subject_key.trait?
+
+          append_values_description(description: description, values: values)
+
+          description.string
+        end
+
+        def collect_overrides(values:, default_key:)
+          result = Hash.new { |hash, key| hash[key] = ValueOverride.new(key: key) }
+          default_values = {}
+
+          values.each do |key, value|
+            case key
+            when Symbol
+              default_values[key] = value
+            when Class
+              key = Key[key]
+              result[key] = result[key].merge_values(value)
+            when Key
+              result[key] = result[key].merge_values(value)
+            else
+              raise ArgumentError, "Illegal override key '#{key}'"
+            end
+          end
+
+          result[default_key] = result[default_key].merge_values(default_values) unless default_values.empty?
+          result.default_proc = nil
+
+          result
+        end
+
+        protected
+
+        def append_values_description(description:, values:)
+          unless values.empty?
+            values.each_with_index do |(name, value), index|
+              description << case index
+              when 0
+                " where "
+              when values.size - 1
+                " and "
+              else
+                ", "
+              end
+
+              description << name
+
+              description << case value
+              when NilClass
+                "is not set"
+              when TrueClass
+                "is true"
+              when FalseClass
+                "is false"
+              else
+                "is set"
+              end
+            end
+          end
+
+          description
+        end
+      end
+
+      attr_reader :description, :parent, :overrides
+
+      def initialize(parent:, subject_key:, description:, overrides:)
+        @parent = parent
+        @subject_key = subject_key
+        @description = description
+
+        @children = []
+
+        factories = overrides.map do |key, override|
+          parent_factory = parent.lookup_factory(key: key)
+
+          factory = Build::Factory.new(
+            parent: parent_factory,
+            context: self,
+            key: key,
+            name: parent_factory&.name || BasicContext.default_factory_name(test_class: test_class, key: key),
+            source_location: Kernel.caller_locations(0, 1).first
+          )
+
+          factory.add_values(override.values)
+
+          factory
+        end
+
+        @factories = factories.map { |f| [f.key, f] }.to_h
+        @named_factories = factories.map { |f| [f.name, f] }.to_h
+      end
+
+      def setup; end
+
+      def subtree_root?
+        false
+      end
+
+      def add_context(context, &block)
+        @children << context
+
+        context.setup
+      end
+
+      def test_class
+        parent&.test_class || raise(StandardError, "No parent context defines a test class")
+      end
+
+      def subject_key
+        @subject_key || (parent.subject_key unless subtree_root? || parent.nil?)
+      end
+
+      def context_path(subtree: true)
+        add_context_to_path([], subtree: subtree).freeze
+      end
+
+      def full_description
+        context_path.reduce(StringIO.new) do |description, context|
+          description << " " if description.length.positive? && context.separate_description_by_space?
+          description << context.description
+        end.string
+      end
+
+      def root
+        result = self
+        result = result.parent until result.parent.nil?
+        result
+      end
+
+      def add_factory(factory)
+        raise KeyError, "Factory for type #{factory.key.type} already defined" if @factories.key?(factory.key.type)
+        raise KeyError, "Factory with name #{factory.name} already defined" if @named_factories.key?(factory.name)
+
+        @factories[factory.key] = factory
+        @named_factories[factory.name] = factory
+
+        test_class.__define_factory_method(factory: factory)
+      end
+
+      def factories
+        @factories.dup.freeze
+      end
+
+      def named_factories
+        @named_factories.dup.freeze
+      end
+
+      def lookup_factory(key:)
+        @factories[key] || @parent&.lookup_factory(key: key)
+      end
+
+      def lookup_named_factory(name:)
+        @named_factories[name] || @parent&.lookup_named_factory(name: name)
+      end
+
+      def create_subject(environment:, subject_key:)
+        @parent.create_subject(environment: environment, subject_key: subject_key)
+      end
+
+      def create_result(subject:, arguments:, options:, block:)
+        @parent.create_result(subject: subject, arguments: arguments, options: options, block: block)
+      end
+
+      protected
+
+      def effective_overrides
+        context_path.each_with_object({}) do |context, overrides|
+          overrides.merge!(context.overrides) do |_key, existing_override, additional_override|
+            existing_override.merge(additional_override)
+          end
+        end
+      end
+
+      def add_context_to_path(path, subtree: true)
+        @parent.add_context_to_path(path, subtree: subtree) unless @parent.nil? || (subtree && subtree_root?)
+
+        path << self
+      end
+
+      def separate_description_by_space?
+        true
+      end
+    end
+  end
+end