calificador 0.1.0 → 0.2.0

data/lib/calificador/{spec → context}/test_method.rb

@@ -1,17 +1,9 @@
 # frozen_string_literal: true
 
-using Calificador::Util::CoreExtensions
-
 module Calificador
-  module Spec
+  module Context
     # Factory class
     class TestMethod < BasicContext
-      class Dsl < BasicContext::Dsl
-        def body(&block)
-          delegate.body = block
-        end
-      end
-
       attr_reader :body, :expected_to_fail
 
       def initialize(parent:, subject_key:, description:, overrides:, expected_to_fail: false, body:)
@@ -28,7 +20,7 @@ module Calificador
 
         test_class.class_eval(<<~METHOD, file, line_number)
           define_method(test_method_name) do
-            __run_test(test_method: test_method)
+            __run_test(context: test_method)
           end
         METHOD
 
@@ -38,27 +30,6 @@ module Calificador
       def method_name
         @method_name ||= "test_: #{full_description}"
       end
-
-      def run_test(test:)
-        body = self.body
-        environment = TestEnvironment.new(test: test, context: self)
-
-        if expected_to_fail
-          passed = begin
-            environment.instance_exec(&body)
-            true
-          rescue ::Minitest::Assertion => e
-            test.pass(e.message)
-            false
-          end
-
-          test.flunk("Expected test to fail") if passed
-        else
-          environment.instance_exec(&body)
-        end
-
-        environment.__done
-      end
     end
   end
 end

data/lib/calificador/{spec → context}/test_root.rb

@@ -1,20 +1,12 @@
 # frozen_string_literal: true
 
-using Calificador::Util::CoreExtensions
-
 module Calificador
-  module Spec
-    class TestRoot < ExamineContext
-      class Dsl < ExamineContext::Dsl
-        def body(&block)
-          delegate.body = block
-        end
-      end
-
+  module Context
+    class TestRoot < InstanceContext
       attr_accessor :test_class
 
       def initialize(test_class:, subject_key:, description:, &body)
-        super(parent: nil, subject_key: subject_key, description: description, overrides: {})
+        super(parent: nil, subject_key: subject_key, description: description)
 
         @test_class = test_class
         @body = body
@@ -30,10 +22,6 @@ module Calificador
         super
       end
 
-      def create_result(subject:, arguments:, options:, block:)
-        subject
-      end
-
       protected
 
       def setup_body

data/lib/calificador/{spec/examine_context.rb → context/type_context.rb}

@@ -1,24 +1,21 @@
 # frozen_string_literal: true
 
-using Calificador::Util::CoreExtensions
-
 module Calificador
-  module Spec
-    class ExamineContext < BasicContext
-      class Dsl < BasicContext::Dsl
-      end
+  module Context
+    class TypeContext < BasicContext
+      def initialize(parent:, subject_key:, description:, overrides: [])
+        raise ArgumentError, "Subject must be a must be a #{BasicObject}" unless subject_key.type <= BasicObject
 
-      def initialize(parent:, subject_key:, description:, overrides: {})
         super(
           parent: parent,
           description: description,
           subject_key: subject_key,
-          overrides: overrides,
+          overrides: overrides
         )
       end
 
-      def create_subject(environment:, subject_key:)
-        environment.create_object(key: subject_key)
+      def create_subject(environment:)
+        subject_key.type
       end
 
       def subtree_root?

data/lib/calificador/key.rb

@@ -2,27 +2,36 @@
 
 require "minitest"
 
-using Calificador::Util::CoreExtensions
-
 module Calificador
   # Test subject key
   class Key
+    NO_TRAIT = :"<none>"
     DEFAULT_TRAIT = :"<default>"
-    INHERITED_TRAIT = :"<inherited>"
 
     class << self
-      def [](type, trait = DEFAULT_TRAIT)
+      def [](type, trait = NO_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
+    def initialize(type:, trait: NO_TRAIT)
+      trait ||= NO_TRAIT
+
+      raise ArgumentError, "Type must be a #{Module}, not '#{type}' (#{type.class})" unless type.is_a?(Module)
+      raise ArgumentError, "Trait must be a #{Symbol}" unless trait.is_a?(Symbol)
 
       @type = type
-      @trait = trait || DEFAULT_TRAIT
+      @trait = trait
+    end
+
+    def trait?
+      @trait != NO_TRAIT && @trait != DEFAULT_TRAIT
+    end
+
+    def default_trait?
+      @trait == DEFAULT_TRAIT
     end
 
     def hash
@@ -30,30 +39,33 @@ module Calificador
     end
 
     def ==(other)
-      (@type == other.type) && (@trait == other.trait)
+      other.is_a?(Key) && (@type == other.type) && (@trait == other.trait)
     end
 
     alias_method :eql?, :==
 
-    def to_s
-      trait == DEFAULT_TRAIT ? type.to_s : "#{type} (#{trait})"
+    def to_s(base_module: nil)
+      type_name = @type.name_without_common_parents(base: base_module)
+      @trait == NO_TRAIT ? type_name : "#{type_name} (#{@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)
+        self
       else
         trait == @trait ? self : Key.new(type: @type, trait: trait)
       end
     end
 
-    def trait?
-      @trait != DEFAULT_TRAIT
+    def with_default(key)
+      if @trait == DEFAULT_TRAIT && @trait != key.trait
+        Key[@type, key.trait]
+      else
+        self
+      end
     end
   end
 end

data/lib/calificador/minitest/minitest_patches.rb

@@ -2,8 +2,6 @@
 
 require "minitest/test"
 
-using Calificador::Util::CoreExtensions
-
 module Calificador
   module Minitest
     # Patches to minitest classes

data/lib/calificador/test.rb

@@ -2,11 +2,9 @@
 
 require "minitest"
 
-using Calificador::Util::CoreExtensions
-
 module Calificador
   # Base class for unit tests
   class Test < ::Minitest::Test
-    include TestMixin
+    prepend TestMixin
   end
 end

data/lib/calificador/test_mixin.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 require "minitest"
-
-using Calificador::Util::CoreExtensions
+require "forwardable"
 
 module Calificador
   # Mixin for unit tests
   module TestMixin
+    extend Forwardable
+
     Key = Calificador::Key
 
     class << self
@@ -19,189 +20,155 @@ module Calificador
       end
     end
 
-    def __run_test(test_method:)
+    def singleton_method_added(method)
+      raise "Adding singleton methods (#{method}) to tests is not supported here" if __current_test_environment?
+
+      super
+    end
+
+    def_delegator :__current_test_environment, :subject
+    def_delegator :__current_test_environment, :create
+
+    def __run_test(context:)
       stack_marker = "calificador_test_#{SecureRandom.uuid.gsub("-", "_")}"
 
-      __register_current_run(stack_marker: stack_marker, test_method: test_method)
+      environment = Context::TestEnvironment.new(parent: context, test_instance: self)
+      __register_current_environment(stack_marker: stack_marker, environment: environment)
 
       begin
         instance_eval(<<~METHOD, stack_marker, 1)
-          test_method.run_test(test: self)
+          environment.run_test
         METHOD
       ensure
-        __unregister_current_run(stack_marker: stack_marker)
+        __unregister_current_environment(stack_marker: stack_marker)
       end
     end
 
     protected
 
-    TestRun = Struct.new(:test_instance, :test_method, keyword_init: true)
-
-    def __register_current_run(stack_marker:, test_method:)
-      @__calificador_current_test_run = TestRun.new(test_instance: self, test_method: test_method)
-      Calificador::Test.__register_current_run(stack_marker: stack_marker, test_run: @__calificador_current_test_run)
+    def __register_current_environment(stack_marker:, environment:)
+      @__calificador_current_test_environment = environment
+      Calificador::Test.__register_current_environment(stack_marker: stack_marker, environment: environment)
     end
 
-    def __unregister_current_run(stack_marker:)
-      if !instance_variable_defined?(:@__calificador_current_test_run) || @__calificador_current_test_run.nil?
+    def __unregister_current_environment(stack_marker:)
+      if !instance_variable_defined?(:@__calificador_current_test_environment) || @__calificador_current_test_environment.nil?
         raise StandardError, "No current test run registered"
       end
 
-      Calificador::Test.__unregister_current_run(stack_marker: stack_marker)
-      @__calificador_current_test_run = nil
+      Calificador::Test.__unregister_current_environment(stack_marker: stack_marker)
+      @__calificador_current_test_environment = nil
     end
 
-    def __current_test_run
-      if !instance_variable_defined?(:@__calificador_current_test_run) || @__calificador_current_test_run.nil?
+    def __current_test_environment
+      if !instance_variable_defined?(:@__calificador_current_test_environment) || @__calificador_current_test_environment.nil?
         raise StandardError, "No current test run registered"
       end
 
-      @__calificador_current_test_run
+      @__calificador_current_test_environment
+    end
+
+    def __current_test_environment?
+      instance_variable_defined?(:@__calificador_current_test_environment) || !@__calificador_current_test_environment
     end
 
     # Class methods for unit tests
     module ClassMethods
+      extend Forwardable
+
       def run_all_tests(reporter: MiniTest::CompositeReporter.new)
         runnable_methods.each do |method|
           run_one_method(self, method, reporter)
         end
       end
 
-      def examines(type = MISSING, trait: MISSING)
-        self.__subject_type = type unless type.equal?(MISSING)
-        self.__subject_trait = trait unless trait.equal?(MISSING)
-
-        Key[__subject_type, __subject_trait]
-      end
-
-      def factory(type, description = nil, name: nil, &block)
-        __root_context.dsl_config do
-          factory(type, description, name: nil, &block)
-        end
-      end
-
-      def examine(subject_type, description = nil, trait: Key::INHERITED_TRAIT, **values, &block)
-        __root_context.dsl_config do
-          examine(subject_type, description, trait: trait, **values, &block)
-        end
-      end
-
-      def method(method, description = nil, **values, &block)
-        __root_context.dsl_config do
-          method(method, description, &block)
+      def examines(subject_class, *description_or_trait_or_init)
+        if instance_variable_defined?(:@__calificador_root_context) && @__calificador_root_context
+          raise <<~MESSAGE.gsub("\n", " ")
+            Cannot specify 'examines' after a test context has been defined. The 'examines' statement should be the first statement in your test class
+          MESSAGE
         end
-      end
 
-      def class_method(method, description = nil, **values, &block)
-        __root_context.dsl_config do
-          class_method(method, description, &block)
-        end
-      end
+        arguments = Context::BasicContext.extract_arguments(
+          subject_key: Key[subject_class],
+          values: description_or_trait_or_init,
+          names: %i[description trait init]
+        )
 
-      def must(description, trait: Key::INHERITED_TRAIT, **values, &block)
-        __root_context.dsl_config do
-          must(description, trait: trait, **values, &block)
-        end
-      end
+        arguments.description ||= __default_instance_description(subject_key: arguments.subject_key)
 
-      def must_fail(description, trait: Key::INHERITED_TRAIT, **values, &block)
-        __root_context.dsl_config do
-          must_fail(description, trait: trait, **values, &block)
-        end
+        @__calificador_root_context = Context::TestRoot.new(
+          test_class: self,
+          subject_key: arguments.subject_key,
+          description: arguments.description
+        )
       end
 
-      def with(description, trait: Key::INHERITED_TRAIT, **values, &block)
-        __root_context.dsl_config do
-          with(description, trait: trait, **values, &block)
-        end
-      end
-
-      def without(description, trait: Key::INHERITED_TRAIT, **values, &block)
-        __root_context.dsl_config do
-          without(description, trait: trait, **values, &block)
-        end
-      end
-
-      def where(description, trait: Key::INHERITED_TRAIT, **values, &block)
-        __root_context.dsl_config do
-          where(description, trait: trait, **values, &block)
-        end
-      end
+      def_delegators :__calificador_current_context, :factory, :mock
+      def_delegators :__calificador_current_context, :type, :examine, :operation, :with, :without, :where
+      def_delegators :__calificador_current_context, :must, :must_fail
+      def_delegators :__calificador_current_context, :args, :props
 
       def body(&block)
         class_eval(&block)
       end
 
-      def __subject_type
-        if !instance_variable_defined?(:@__calificador_subject_type) || @__calificador_subject_type.nil?
-          type_name = name.gsub(%r{(?<=\w)Test\z}, "")
-
-          if Kernel.const_defined?(type_name)
-            @__calificador_subject_type = Kernel.const_get(type_name)
-          else
-            raise StandardError, "Cannot determine test subject type from test class name '#{name}'"
-          end
-        end
-
-        @__calificador_subject_type
+      def __default_type_description(subject_key:)
+        subject_key.type.name_without_common_parents(base: self)
       end
 
-      def __subject_type=(type)
-        if instance_variable_defined?(:@__calificador_subject_type) && !@__calificador_subject_type.nil?
-          raise StandardError, "Cannot redefine test subject type"
-        end
+      def __default_instance_description(subject_key:)
+        description = StringIO.new
 
-        @__calificador_subject_type = type
-      end
+        description << subject_key.type.name_without_common_parents(base: self)
+        description << "(" << subject_key.trait.to_s.gsub("_", " ") << ")" if subject_key.trait?
 
-      def __subject_trait
-        if !instance_variable_defined?(:@__calificador_subject_trait) || @__calificador_subject_trait.nil?
-          @__calificador_subject_trait = Key::DEFAULT_TRAIT
-        end
-
-        @__calificador_subject_trait
+        description.string
       end
 
-      def __subject_trait=(trait)
-        if instance_variable_defined?(:@__calificador_subject_trait) && !@__calificador_subject_trait.nil?
-          raise StandardError, "Cannot redefine test subject trait"
-        end
+      def __default_factory_name(subject_key:)
+        description = StringIO.new
+
+        description << subject_key.type.base_name.snake_case
+        description << "_" << subject_key.trait.to_s if subject_key.trait?
 
-        @__calificador_subject_trait = trait
+        description.string
       end
 
       def __root_context
         if !instance_variable_defined?(:@__calificador_root_context) || @__calificador_root_context.nil?
-          description = __subject_type.name.delete_prefix(parent_prefix)
-          description = "#{description} {#{__subject_trait}}" unless __subject_trait.equal?(Key::DEFAULT_TRAIT)
+          subject_key = __calificador_guess_subject_key
 
-          @__calificador_root_context = Spec::TestRoot.new(
+          @__calificador_root_context = Context::TestRoot.new(
             test_class: self,
-            subject_key: Key[__subject_type, __subject_trait],
-            description: description
+            subject_key: subject_key,
+            description: __default_instance_description(subject_key: subject_key)
           )
         end
 
         @__calificador_root_context
       end
 
-      def __register_current_run(stack_marker:, test_run:)
+      def __register_current_environment(stack_marker:, environment:)
         __calificador_test_lock.synchronize do
-          raise KeyError, "Test run #{stack_marker} already registered" if __calificador_test_runs.key?(stack_marker)
+          if __calificador_test_environments.key?(stack_marker)
+            raise KeyError,
+                  "Test run #{stack_marker} already registered"
+          end
 
-          __calificador_test_runs[stack_marker] = test_run
+          __calificador_test_environments[stack_marker] = environment
         end
       end
 
-      def __unregister_current_run(stack_marker:)
+      def __unregister_current_environment(stack_marker:)
         __calificador_test_lock.synchronize do
-          if __calificador_test_runs.delete(stack_marker).nil?
+          if __calificador_test_environments.delete(stack_marker).nil?
             raise KeyError, "Could not unregister test #{stack_marker}"
           end
         end
       end
 
-      def __current_test_run
+      def __current_test_environment
         __calificador_test_lock.synchronize do
           location = ::Kernel.caller_locations.find do |l|
             %r{\Acalificador_test_[a-zA-Z0-9_]+\z} =~ l.path
@@ -209,49 +176,59 @@ module Calificador
 
           raise StandardError, "Could not find current test run in call stack" unless location
 
-          __calificador_test_runs.fetch(location.path) do
+          __calificador_test_environments.fetch(location.path) do
             raise KeyError, "No test run registered for #{location.path}"
           end
         end
       end
 
-      def __factory_methods
-        @__calificador_factory_methods = Set.new unless instance_variable_defined?(:@__calificador_factory_methods)
+      def __calificador_configure(context:, block:)
+        __calificador_push_context(context)
 
-        @__calificador_factory_methods.dup.freeze
+        begin
+          class_exec(&block)
+        ensure
+          __calificador_pop_context
+        end
       end
 
-      def __define_factory_method(factory:)
-        @__calificador_factory_methods = Set.new unless instance_variable_defined?(:@__calificador_factory_methods)
-
-        if @__calificador_factory_methods.add?(factory.name)
-          factory_method_name = if factory.name.to_s.start_with?("test_")
-            "create_#{factory.name}"
-          else
-            factory.name
-          end
+      def method_added(method)
+        if !method.start_with?("test_: ") && __calificador_contexts.size > 1
+          raise "Adding methods (#{method}) to tests is not supported here"
+        end
 
-          if method_defined?(factory_method_name, true)
-            raise "Cannot define factory method #{factory_method_name}, method already exists in #{self.class}"
-          end
+        super
+      end
 
-          type = factory.key.type # rubocop:disable Lint/UselessAssignment
-          trait = factory.key.trait # rubocop:disable Lint/UselessAssignment
+      protected
 
-          class_eval(<<~METHOD, factory.source_location.first, factory.source_location.last)
-            define_method(factory_method_name) do
-              __current_test_run.test_method.create(type: type, trait: trait)
-            end
-          METHOD
+      def __calificador_contexts
+        if !instance_variable_defined?(:@__calificador_contexts) || @__calificador_contexts.nil?
+          @__calificador_contexts = [__root_context]
         end
+
+        @__calificador_contexts
       end
 
-      protected
+      def __calificador_push_context(context)
+        __calificador_contexts.push(context)
+        context
+      end
 
-      def __calificador_test_runs
-        @__calificador_test_runs = {} unless instance_variable_defined?(:@__calificador_test_runs)
+      def __calificador_pop_context
+        raise "Cannot remove root context" unless __calificador_contexts.size > 1
+
+        __calificador_contexts.pop
+      end
 
-        @__calificador_test_runs
+      def __calificador_current_context
+        __calificador_contexts.last
+      end
+
+      def __calificador_test_environments
+        @__calificador_test_environments = {} unless instance_variable_defined?(:@__calificador_test_environments)
+
+        @__calificador_test_environments
       end
 
       def __calificador_test_lock
@@ -259,6 +236,33 @@ module Calificador
 
         @__calificador_test_lock
       end
+
+      def __calificador_guess_subject_key
+        type_name = name&.gsub(%r{(?<=\w)Test\z}, "")
+
+        unless type_name
+          raise StandardError, <<~MESSAGE.gsub("\n", " ")
+            Cannot guess test subject class from test class name '#{name}'. Please use 'examines' to specify the test subject.
+          MESSAGE
+        end
+
+        unless Kernel.const_defined?(type_name)
+          raise StandardError, <<~MESSAGE.gsub("\n", " ")
+            Guessed test subject type (#{type_name}) does not exist. Please use 'examines' to specify the test subject.
+          MESSAGE
+        end
+
+        subject_type = Kernel.const_get(type_name)
+
+        if subject_type <= Singleton || subject_type <= BasicObject || subject_type.is_a?(Module)
+          Key[subject_type]
+        else
+          raise StandardError, <<~MESSAGE.gsub("\n", " ")
+            Guessed test subject type (#{subject_type}) is not a Class, a Module or a Singleton. Please use 'examines'
+            to specify the test subject.
+          MESSAGE
+        end
+      end
     end
   end
 end