calificador 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f7600ea7641198f91585844a8701550ba999fb7b2e91c49a4d0c4e1728429d7
-  data.tar.gz: 9b81427ec6996cb065868cac1d0406f0af6262163c442f33b193709d838498a9
+  metadata.gz: 391cd5fa12b8710d063b8523dbb6d3350c13162ff241279c5d979ce9b7a3b555
+  data.tar.gz: 0d0527fda2ab45e903f057d6cd22a23588cde7b1a7c4ad352c718dc577785d59
 SHA512:
-  metadata.gz: 27229e0b80d7da65f9c9c039070b2aa42981a9d64408e2c687ec7ee1af24a82ec70eb678d03ff8e3c1d57272cc8ce45734236991b4b325ea824a2597afb356b2
-  data.tar.gz: 2d0ef75a9ed7549a0deaeb5d5b62c8d277db62b8dc2c3a7ac3f1f5c8e33e9b325f3a56a7c426eff5a469dd491cdf2839c5007170f92321f3d26e94ff2484507b
+  metadata.gz: 588366fbb53142a962e3a18b4b6fdfc9232729f22967d2ceb2105bd032293fea21d7c41ba3650d48a85827a12e926de27be63fe9523a6b9913aebb2f23fa4b39
+  data.tar.gz: 24c4a70eebd0528f2fb6a041a7283f65b23636048f480632e5975b6e78c862b479f0202142d45f2b9e77c3ee089b4852e4f0172989071e3f0390e10f833449c1

data/README.md

@@ -1,4 +1,4 @@
-## What is it?
+# What is it?
 
 A small Gem that lets you write concise and readable unit tests. It is heavily inspired by [Minitest], [Factory Bot], and [Assertive Expressive] but tries to boil everything down to be as concise as possible:
 
@@ -6,12 +6,18 @@ A small Gem that lets you write concise and readable unit tests. It is heavily i
     module ReadMe
       require "calificador"
 
-      # Define a test class
+      # Define class to test
       class HighTea
         attr_accessor :scones, :posh
 
+        def initialize(scones:)
+          raise ArgumentError, "Cannot have a negative amount of scones" if scones.negative?
+
+          @scones = scones
+        end
+
         def eat_scone
-          raise "Out of scones" if scones == 0
+          raise "Out of scones" if scones.zero?
 
           @scones -= 1
         end
@@ -27,37 +33,50 @@ A small Gem that lets you write concise and readable unit tests. It is heavily i
 
         # Define a factory for the test subject
         factory HighTea do
-          scones { 2 }
+          # Set properties on the created object
           posh { false }
 
-          # Use raits to define variants of your test subject
+          # Define transient properties that will not be set automatically
+          transient do
+            # Constructor arguments are automatically set from properties
+            scones { 2 }
+          end
+
+          # Use traits to define variants of your test subject
           trait :style do
             posh { true }
           end
         end
 
-        # Define test method
-        must "have tea and scones" do
-          # Write assertions using plain Ruby methods instead of spec DSL methods
-          refute { subject.tea }.nil?
-          assert { subject.scones } > 0
+        # Test class methods
+        type do
+          operation :new do
+            must "set a default amount of scones" do
+              # Write assertions using plain Ruby methods instead of spec DSL methods
+              assert { subject.scones } > 0
+            end
+
+            must "provide an instance that has tea" do
+              refute { subject.tea }.nil?
+            end
+          end
         end
 
-        # Get nice test names. This one will be called "HighTea must have me let a scone"
+        # Get nice test names. This one will be called "HighTea must let me have a scone"
         must "let me have a scone" do
           count = subject.scones
           subject.eat_scone
           assert { subject.scones } == count - 1
         end
 
-        # Adjust test subject using traits or properties for minor variations
-        must "complain if out of scones", scones: 0 do
+        # Modify test subject using traits or properties for minor variations
+        must "complain if out of scones", props { scones { 0 } } do
           assert { subject.eat_scone }.raises?(StandardError)
         end
 
         # Create subcontexts for variations of the test subject using traits and properties
         with :style do
-          # Still nice test names. This one is "HighTea with style should have expensive tea"
+          # Still nice test names. This one is "HighTea with style must have expensive tea"
           must "have expensive tea" do
             assert { subject.tea }.include?("First Flush")
           end
@@ -79,8 +98,8 @@ Calificador is an experiment in getting rid of as much mental load, boilerplate
 
 Only a handful of DSL methods are required:
 
-* Test structure: examine, must, where/with/without
-* Factory methods: factory, traits
+* Test structure: examine, type, operation, where/with/without, must
+* Factory methods: factory, mock, traits
 * Assertions: assert, refute and raises?
 
 It also tries to keep things simple by avoiding all the special assertion and expectation methods you need to learn for other test frameworks. Instead of having to learn that `include` is the RSpec matcher for `include?`, or Minitest's `assert_match` is used to assert regular expression matches, you can write `refute { something }.include? "value"` or `assert { something }.match %r{pattern}` using Ruby's normal `String#match` method.

data/TODO.md

@@ -0,0 +1,16 @@
+# TODOs
+
+## must
+
+```ruby
+must "description", trait, properties, arguments
+```
+
+
+M1==>inspect
+M1==>inspect
+M1==>methods
+M1==>private_methods
+M1==>instance_variables
+M1==>class
+M1==>kind_of?

data/calificador.gemspec

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+LIB_DIR = File.join(__dir__, "lib")
+$LOAD_PATH.unshift(LIB_DIR) unless $LOAD_PATH.include?(LIB_DIR)
+
+require "calificador/version"
+require "json"
+require "pathname"
+
+Gem::Specification.new do |spec|
+  raise "RubyGems 2.0 or newer is required." unless spec.respond_to?(:metadata)
+
+  spec.name = "calificador"
+  spec.version = Calificador::VERSION
+  spec.summary = "Concise and readable unit tests"
+
+  spec.required_ruby_version = ">= 2.7"
+
+  spec.authors = ["Jochen Seeber"]
+  spec.email = ["jochen@seeber.me"]
+  spec.homepage = "https://github.com/jochenseeber/calificador"
+
+  spec.metadata["issue_tracker"] = "https://github.com/jochenseeber/calificador/issues"
+  spec.metadata["documentation"] = "http://jochenseeber.github.com/calificador"
+  spec.metadata["source_code"] = "https://github.com/jochenseeber/calificador"
+  spec.metadata["wiki"] = "https://github.com/jochenseeber/calificador/wiki"
+
+  spec.files = Dir[
+    "*.gemspec",
+    "*.md",
+    "*.txt",
+    "lib/**/*.rb",
+  ]
+
+  spec.require_paths = [
+    "lib",
+  ]
+
+  spec.bindir = "cmd"
+  spec.executables = spec.files.filter { |f| File.dirname(f) == "cmd" && File.file?(f) }.map { |f| File.basename(f) }
+
+  spec.add_dependency "minitest", "~> 5.14"
+  spec.add_dependency "zeitwerk", "~> 2.3"
+
+  spec.add_development_dependency "bundler", "~> 2.1"
+  spec.add_development_dependency "debase", "~> 0.2"
+  spec.add_development_dependency "qed", "~> 2.9"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rubocop", ">= 0.85"
+  spec.add_development_dependency "rubocop-rake", ">= 0.5.1"
+  spec.add_development_dependency "ruby-debug-ide", "~> 0.7"
+  spec.add_development_dependency "simplecov", "~> 0.18"
+  spec.add_development_dependency "yard", "~> 0.9"
+end

data/lib/calificador.rb

@@ -1,17 +1,21 @@
 # frozen_string_literal: true
 
-require "zeitwerk"
+require "calificador/util/core_extensions"
 require "minitest"
+require "pathname"
+require "zeitwerk"
 
 loader = Zeitwerk::Loader.for_gem
 loader.setup
 
 # Main module
 module Calificador
-  using Calificador::Util::CoreExtensions
-
   MISSING = Util::Missing.instance
 
+  BASE_DIR = Pathname(__FILE__).expand_path.dirname
+
+  METHOD_PATTERN = %r{[[:alpha:]](?:[[:alnum:]]|_)*}.freeze
+
   class << self
     attr_writer :call_formatter
 
@@ -40,5 +44,5 @@ module Calificador
   end
 end
 
-Minitest::Assertion.prepend(Calificador::Minitest::MinitestPatches::AssertionMethods)
 Class.include(Calificador::Util::ClassMixin)
+Minitest::Assertion.prepend(Calificador::Minitest::MinitestPatches::AssertionMethods)

data/lib/calificador/assert.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "calificador"
+
+module Calificador
+  module Assert
+    def assert(&block)
+      Calificador::Assertor.new(block: block)
+    end
+
+    def refute(&block)
+      Calificador::Assertor.new(negated: true, block: block)
+    end
+  end
+end

data/lib/calificador/assertor.rb

@@ -1,64 +1,67 @@
 # frozen_string_literal: true
 
 require "minitest"
+require "singleton"
 
 module Calificador
-  class Assertor < BasicObject
-    def initialize(test:, negated: false, block: nil)
-      @test = test
+  class Assertor < Util::ProxyObject
+    class DefaultHandler
+      include Singleton
+
+      def assert(condition, message)
+        raise ::Minitest::Assertion, message unless condition
+      end
+
+      def refute(condition, message) 
+        raise ::Minitest::Assertion, message if condition
+      end
+    end
+
+    def initialize(handler: DefaultHandler.instance, negated: false, block: nil)
+      super()
+
+      @handler = handler
       @negated = negated ? true : false
       @block = block
       @value = MISSING
       @triggered = false
     end
 
-    def respond_to?(method, include_all = false)
-      __value.respond_to?(method, include_all) || super
-    end
-
-    def method_missing(method, *arguments, **options, &block) # rubocop:disable Style/MissingRespondToMissing
-      if __value.respond_to?(method)
-        __check(method: method, arguments: arguments, options: options, &block)
-      else
-        super
-      end
-    end
-
     def ==(other)
       message = ::Kernel.proc do
-        actual = ::Calificador.call_formatter.value(value: __value)
-        expected = ::Calificador.call_formatter.value(value: other)
+        actual = ::Calificador.call_formatter.format_value(value: __value)
+        expected = ::Calificador.call_formatter.format_value(value: other)
 
         "Expected #{actual} (#{__value.class}) to#{@negated ? " not" : ""} be equal to #{expected} (#{other.class})"
       end
 
-      __check(method: :"==", message: message, arguments: [other])
+      __check(name: :"==", message: message, arguments: [other])
     end
 
     def !=(other)
       message = ::Kernel.proc do
-        actual = ::Calificador.call_formatter.value(value: __value)
-        expected = ::Calificador.call_formatter.value(value: other)
+        actual = ::Calificador.call_formatter.format_value(value: __value)
+        expected = ::Calificador.call_formatter.format_value(value: other)
 
         "Expected #{actual} (#{__value.class})  to#{@negated ? "" : " not"} be equal to #{expected} (#{other.class})"
       end
 
-      __check(method: :"!=", message: message, arguments: [other])
+      __check(name: :"!=", message: message, arguments: [other])
     end
 
     def identical?(other)
       message = ::Kernel.proc do
-        actual = ::Calificador.call_formatter.value(value: __value)
-        expected = ::Calificador.call_formatter.value(value: other)
+        actual = ::Calificador.call_formatter.format_value(value: __value)
+        expected = ::Calificador.call_formatter.format_value(value: other)
 
         "Expected #{actual} (#{__value.class}) to#{@negated ? " not" : ""} be identical to #{expected} (#{other.class})"
       end
 
-      __check(method: :"equal?", message: message, arguments: [other])
+      __check(name: :"equal?", message: message, arguments: [other])
     end
 
     def not
-      Assertor.new(test: @test, negated: !@negated, block: @block)
+      Assertor.new(handler: @handler, negated: !@negated, block: @block)
     end
 
     def raises?(*exception_classes, &block)
@@ -70,23 +73,23 @@ module Calificador
       ::Kernel.raise ::ArgumentError, "Exception assert must have a block" if block.nil?
 
       message = ::Kernel.proc do
-        actual = ::Calificador.call_formatter.value(value: @block)
+        actual = ::Calificador.call_formatter.format_value(value: @block)
         "Expected #{actual} (#{@block}) to#{@negated ? " not" : ""} raise #{exception_classes.join(", ")}"
       end
 
       begin
         result = block.call
 
-        @test.assert(@negated, message)
+        __assert(@negated, message: message)
 
         result
       rescue *exception_classes => e
-        @test.refute(@negated, @test.exception_details(e, message.call))
+        __refute(@negated, message: __exception_details(e, message: message))
         e
       rescue ::Minitest::Assertion, ::SignalException, ::SystemExit
         ::Kernel.raise
       rescue ::Exception => e # rubocop:disable Lint/RescueException
-        @test.assert(@negated, @test.exception_details(e, message.call))
+        __assert(@negated, message: __exception_details(e, message: message))
       end
     end
 
@@ -101,6 +104,18 @@ module Calificador
 
     protected
 
+    def __respond_to_missing?(name:, include_all:)
+      __value.respond_to?(name, false)
+    end
+
+    def __method_missing(name:, arguments:, keywords:, block:)
+      if __value.respond_to?(name)
+        __check(name: name, arguments: arguments, keywords: keywords, &block)
+      else
+        super
+      end
+    end
+
     def __value
       if @value.equal?(MISSING)
         ::Kernel.raise ::StandardError, "No block set for assertion" if @block.nil?
@@ -111,24 +126,53 @@ module Calificador
       @value
     end
 
-    def __check(method:, message: nil, arguments: [], options: {}, &block)
+    def __check(name:, message: nil, arguments: [], keywords: {}, &block)
       @triggered = true
 
-      result = __value.send(method, *arguments, **options, &block)
+      result = begin
+        __value.send(name, *arguments, **keywords, &block)
+      rescue ::StandardError => e
+        raise ::Minitest::UnexpectedError, e
+      end
 
       message ||= ::Kernel.proc do
-        actual = ::Calificador.call_formatter.value(value: __value)
-        call = ::Calificador.call_formatter.method(method: method, arguments: arguments, options: options)
+        actual = ::Calificador.call_formatter.format_value(value: __value)
+        call = ::Calificador.call_formatter.format_method(name: name, arguments: arguments, keywords: keywords)
         "Expected #{actual} (#{__value.class}) to#{@negated ? " not" : ""} #{call}"
       end
 
       if @negated
-        @test.refute(result, message)
+        __refute(result, message: message)
       else
-        @test.assert(result, message)
+        __assert(result, message: message)
       end
 
       result
     end
+
+    def __assert(condition, message:)
+      message = message.call if !condition && message.is_a?(::Proc)
+
+      @handler.assert(condition, message)
+    end
+
+    def __refute(condition, message:)
+      message = message.call if condition && message.is_a?(::Proc)
+
+      @handler.refute(condition, message)
+    end
+
+    def __exception_details(exception, message:)
+      message = message.call if message.is_a?(::Proc)
+
+      [
+        message,
+        "Class: <#{exception.class}>",
+        "Message: #{exception.message}",
+        "---Backtrace---",
+        exception.backtrace.map(&:to_s),
+        "---------------",
+      ].flatten.join("\n")
+    end
   end
 end

data/lib/calificador/build/attribute_evaluator.rb

@@ -1,67 +1,69 @@
 # frozen_string_literal: true
 
-using Calificador::Util::CoreExtensions
-
 module Calificador
   module Build
     class AttributeEvaluator
       EVALUATING = Object.new.freeze
 
-      class Proxy
-        def initialize(delegate:)
-          @delegate = delegate
-        end
+      class Proxy < Util::ProxyObject
+        def initialize(evaluator:)
+          super()
 
-        def create(type, trait = nil)
-          key = Key[type, trait]
-          @delegate.create_object(key: key)
+          @evaluator = evaluator
+          @environment_proxy = evaluator.environment.proxy
         end
 
-        def respond_to_missing?(method, include_all)
-          @delegate.attribute?(name: method) ? true : super
+        protected
+
+        def __respond_to_missing?(name:, include_all:)
+          @evaluator.attribute?(name: name) || @environment_proxy.respond_to?(name)
         end
 
-        def method_missing(method, *arguments, &block)
-          if @delegate.attribute?(name: method)
+        def __method_missing(name:, arguments:, keywords:, block:)
+          if @evaluator.attribute?(name: name)
             raise ArgumentError, "Getter must not be called with arguments" unless arguments.empty?
 
-            @delegate.value(name: method)
+            @evaluator.value(name: name)
           else
-            super
+            @environment_proxy.__send__(name, *arguments, **keywords, &block)
           end
         end
       end
 
-      attr_reader :attributes, :values
+      attr_reader :attributes, :values, :environment
 
-      def initialize(context:)
-        @context = context
+      def initialize(key:, environment:)
+        @key = key
+        @environment = environment
         @attributes = {}
         @values = {}
-        @proxy = Proxy.new(delegate: self)
+        @proxy = Proxy.new(evaluator: self)
       end
 
-      def create_object(key:)
-        @context.create_object(key: key)
-      end
-
-      def add_values(values)
-        @values.merge!(values)
+      def add_attribute(attribute)
+        @attributes[attribute.name] = attribute
       end
 
       def add_attributes(attributes)
         attributes.each do |attribute|
-          @attributes[attribute.name] = attribute
+          add_attribute(attribute)
         end
       end
 
+      def add_values(values)
+        @values.merge!(values)
+      end
+
       def value(name:)
         result = @values.fetch(name) do
           @values[name] = EVALUATING
 
           begin
-            config = @attributes.fetch(name).config
-            @values[name] = evaluate(&config)
+            attribute = @attributes.fetch(name) do
+              raise KeyError, "Could not find attribute '#{name}' for factory #{@key}"
+            end
+
+            @values[name] = evaluate(&attribute.config)
           rescue StandardError
             @values.delete(name)
             raise
@@ -73,10 +75,12 @@ module Calificador
         result
       end
 
-      def evaluate(*arguments, **options, &block)
-        block.invoke_with_target(@proxy, *arguments, **options)
+      def evaluate(*arguments, &block)
+        @proxy.instance_exec(*arguments, &block)
       end
 
+      ruby2_keywords :evaluate
+
       def attribute?(name:)
         @attributes.key?(name)
       end