lesli_testing 1.2.1 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ded980f17f0eecf679e78acf07e9c161172ab5d5fd82fc9f81f39d725886f72
-  data.tar.gz: 02b7b1279b175c6fb46d1818d190a920e40da7dfe34003c332237db2902f2d90
+  metadata.gz: d3f8b488a261e18bdf9030e0c369c534cd987341222892b3f397467ab382998b
+  data.tar.gz: bc20743265959a07b2acd5b1975b4d59eb9e30ab612d40621c1b8ccc1a86648e
 SHA512:
-  metadata.gz: 8b018fb87570259581b7ebce74b0e50c37fdfb6be788b19d449fe9557d4512a8dca2f4ff4c6fa100394c8da6792b4d9513dab97fbdd154d98e3274f32437c3d3
-  data.tar.gz: f09421aa36f74b8e7a840459d30a0ca9e08187367458810366dc7337cbabf4aa0e94f8caaa9753626043e9c3085955751901156537a787b4c9e9d1e544c418c3
+  metadata.gz: 17f37531c01a9a60131c69bd6cb87c6b4cb8b9a56ab54ddf1cfc04520fda3eb2f03d998f4b1c814ff4f29813ffb93280dbc940a28ba5b23de18d7b81c6b0861b
+  data.tar.gz: e29091cc308623a4f80d4423968c22d6882785dbf4712441567e3435e56f7fc1839e3120e6409fab285542fdae81d532ba364e71e29cea3efc18cfcb3c04f961

data/lib/lesli_testing/config.rb

@@ -38,10 +38,6 @@ module LesliTesting
             # Run tests across all the engines: LESLI_INTEGRATION_TEST=true rails test
             # Run tests for the current engine: rails test
             if engine_module
-                # Migration and Fixture logic goes here...
-                ActiveRecord::Migrator.migrations_paths = [engine_module.root.join("db/migrate").to_s] if defined?(ActiveRecord)
-                ActiveRecord::Migrator.migrations_paths = [engine_module.root.join("db/migrate/1.0").to_s] if defined?(ActiveRecord)
-
 
                 # Load fixtures from the engine
                 if ActiveSupport::TestCase.respond_to?(:fixture_paths=)

data/lib/lesli_testing/coverage.rb

@@ -54,9 +54,9 @@ module LesliTesting
                     "/config", 
                     "/docs",
                     "/db", 
-                    "/lib", 
                     "/test", 
                     "/test/dummy/",
+                    "/lib/tasks", 
                     "/vendor"
                 ]
 

data/lib/lesli_testing/engine.rb

@@ -0,0 +1,67 @@
+=begin
+
+Lesli
+
+Copyright (c) 2026, Lesli Technologies, S. A.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see http://www.gnu.org/licenses/.
+
+Lesli · Ruby on Rails SaaS Development Framework.
+
+Made with ♥ by LesliTech
+Building a better future, one line of code at a time.
+
+@contact  hello@lesli.tech
+@website  https://www.lesli.tech
+@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · 
+=end
+
+module LesliTesting
+    class Engine < ::Rails::Engine
+        initializer "lesli_testing.load_required_migrations", after: :load_config_initializers do |app|
+
+            # Only run this if we are in the test environment
+            unless Rails.env.production?
+
+                # 1. Define the dependencies you want to automatically include
+                # You can add more gems to this list as your ecosystem grows
+                dependencies = ["Lesli"]
+
+                dependencies.each do |gem_name|
+                    begin
+                        # Find the constant for the gem's Engine
+                        gem_engine = "#{gem_name}::Engine".safe_constantize
+
+                        if gem_engine
+                            migration_path = gem_engine.root.join("db/migrate").to_s
+
+                            # Append to the main app's migration paths if the directory exists
+                            if Dir.exist?(migration_path)
+                                app.config.paths["db/migrate"] << migration_path
+                            end
+                        end
+                    rescue StandardError => e
+                        puts "LesliTesting: Could not load migrations for #{gem_name}: #{e.message}"
+                    end
+                end
+
+                # 2. Clean up duplicates
+                app.config.paths["db/migrate"].uniq!
+            end
+        end
+    end
+end

data/lib/lesli_testing/loader.rb

@@ -37,8 +37,8 @@ require "simplecov-cobertura"
 
 
 # Load test frameworks
-require_relative "reporters/cli_reporter"
 require "minitest/lesli_testing_plugin"
+require_relative "reporters/cli_reporter"
 
 # Force Minitest to know about Lesli Minitest reporter plugin
 unless Minitest.extensions.include?("lesli_testing")
@@ -55,16 +55,19 @@ module LesliTesting
 
     class << self
 
-        def start_coverage!(engine_module = nil, options = {})
-            return if defined?(SimpleCov) && SimpleCov.running
+        attr_accessor :engine_module; 
+
+        def configure(engine_module = nil, options = {})
+
+            engine_module = engine_module ? engine_module.name : "RailsApp"
 
-            name = engine_module ? engine_module.name : "RailsApp"
+            return if defined?(SimpleCov) && SimpleCov.running            
 
             # Start Coverage
-            LesliTesting::Coverage.start(name, options[:min_coverage] || 40)
+            LesliTesting::Coverage.start(engine_module, options[:min_coverage] || 40)
         end
 
-        def configure_tests!(engine_module = nil)
+        def configure_tests()
 
             # Apply Minitest/Reporters/Paths
             LesliTesting::Config.apply(engine_module)

data/lib/lesli_testing/reporters/cli_reporter.rb

@@ -7,43 +7,54 @@ module LesliTesting
         class CliReporter < Minitest::StatisticsReporter
             def start
                 super
+
+                Termline.br
+
                 Termline.m(
-                    Termline::Style.colorize(" Running Lesli tests...", :blue),
-                    Termline::Style.colorize(" -> For a better result run test over a clean database", :blue),
-                    Termline::Style.colorize(" -> You can use: rake dev:db:reset", :blue)
+                    Termline::Style.colorize("Running Lesli tests...", :blue),
+                    Termline::Style.colorize("-> For a better result run test over a clean database", :blue),
+                    Termline::Style.colorize("-> You can use: rake dev:db:reset", :blue)
                 )
-                Termline.br
+
+                Termline.br 2
             end
 
             def record(test)
                 super
 
-                assert_color = :green
-                assert_color = :yellow if test.assertions < 5
-                assert_color = :red if test.assertions < 2
-
-                parts = []
-                parts << Termline::Style.colorize('['+Time.now.strftime('%H:%M:%S:%L')+']', :gray)
-                
-                case test.result_code
-                when "."
-                    parts << Termline::Style.colorize("PASS", :green)
-                when "F"
-                    parts << Termline::Style.colorize("FAIL", :red)
-                when "E"
-                    parts << Termline::Style.colorize("ERROR", :red)
-                when "S"
-                    parts << Termline::Style.colorize("SKIP", :yellow)
+                # Only print the line if the configuration allows it
+                return if ENV["QUIET"]
+
+                # Map result codes to styles
+                status_map = { 
+                    "." => [:green, "PASS"], 
+                    "S" => [:yellow, "SKIP"], 
+                    "E" => [:red, "ERROR"], 
+                    "F" => [:red, "FAIL"]
+                }
+                color, label = status_map[test.result_code] || [:gray, "????"]
+
+                # Determine assertion health
+                assert_color = case test.assertions
+                    when 0..1 then :red
+                    when 2..4 then :yellow
+                    else :green
                 end
 
-                parts << '::'
-                parts << Termline::Style.colorize(test.klass, :blue)
-                parts << '->'
-                parts << Termline::Style.colorize(test.name, :skyblue)
-                parts << Termline::Style.colorize("(#{ test.assertions} asserts)", assert_color) 
-                parts << Termline::Style.colorize("#{"(%.2fs)" % test.time}", :red) if test.time > 1 
+                parts = [
+                    Termline::Style.colorize("[#{Time.now.strftime('%H:%M:%S')}]", :gray),
+                    Termline::Style.colorize(label, color),
+                    "::",
+                    Termline::Style.colorize(test.klass, :blue),
+                    "->",
+                    Termline::Style.colorize(test.name, :skyblue),
+                    Termline::Style.colorize("(#{test.assertions} asserts)", assert_color)
+                ]
 
-                puts(parts.compact.join(" ").strip)
+                # Add execution time per test
+                parts << Termline::Style.colorize("(%.2fs)" % test.time, :red) if test.time > 1
+
+                puts(parts.join(" "))
             end
 
             def report
@@ -86,7 +97,7 @@ module LesliTesting
                     Termline.danger("Test suite failed", tag:'FAILURE')
                 end
 
-                Termline.br
+                Termline.br 2
 
                 print_failure_details if total_failures.positive? || total_errors.positive?
 
@@ -104,22 +115,63 @@ module LesliTesting
                     failure_tag = failure.is_a?(Minitest::Assertion) ? "FAILURE" : "ERROR"
                     failure_msg = "#{result.class}##{result.name} (#{result.assertions} asserts)"
 
+                    file, line = result.source_location
+                    location_file = file ? "#{file} (line: #{line})" : "Location unknown"
+
                     Termline.br
                     Termline.line(6)
                     Termline.br
 
+                    puts Termline::Msg.builder(failure_msg, tag: " #{Termline::Style.icon(:error)} #{failure_tag} #{index + 1}:", color: :red, timestamp:nil)
+                    puts Termline::Msg.builder(location_file, tag: " #{Termline::Style.icon(:debug)}  Location:", color: :yellow, timestamp:nil)
+
                     if failure.is_a?(Minitest::Assertion)
-                        Termline::Msg.builder(failure_msg, tag: " #{Termline::Style.icon(:error)} #{failure_tag} #{index + 1}:", color: :red, timestamp:nil)
-                        puts "    #{Termline::Style.colorize('Location:', :yellow)} #{result.source_location.first} (line: #{result.source_location.second})"
-                        puts "    #{Termline::Style.colorize(result.failure.message.to_s.lines.first.strip, :green)}"
-                        puts "      #{Termline::Style.colorize(result.failure.message.to_s.lines.second.strip, :red)}"
-                    else
-                        Termline.warning(failure_msg, tag: failure_tag)
+                        result.failure.message.to_s.lines.each do |message|
+                            puts(parse_minitest_assertion_messages(message))
+                            #puts(parse_minitest_assertion_messages2(message))
+                        end
                     end
                 end
 
                 Termline.br
             end
+
+            def parse_minitest_assertion_messages2 message
+                msg = message.strip
+                return Termline::Style.colorize(" +  #{msg}", :green) if msg.start_with? "Expected:"
+                return Termline::Style.colorize(" -    #{msg}", :red) if msg.start_with? "Actual:"
+                return Termline::Style.colorize(" #{Termline::Style.icon(:warning)}  #{msg}", :yellow)
+            end
+
+            def parse_minitest_assertion_messages(message)
+            msg = message.strip
+
+            case msg
+
+                # 1. Boolean/Nil Failures (e.g., "Expected true to be nil" or "Expected false to be truthy")
+                when /Expected (.*) to be (nil|truthy|falsey)/, /Expected (.*) to be (.*)/
+                    Termline::Style.colorize(" #{Termline::Style.icon(:info)}  #{msg}", :skyblue)
+
+                # 2. Standard Diffs (Expected vs Actual)
+                when /^Expected:?\s+/
+                    Termline::Style.colorize(" #{Termline::Style.icon(:add)}  #{msg}", :green)
+
+                when /^Actual:?\s+/
+                    Termline::Style.colorize(" #{Termline::Style.icon(:remove)}    #{msg}", :red)
+
+                # 3. Rails Difference Failures (e.g., "User.count" didn't change by 1)
+                when /"(.*)" didn't change by (.*)/, /actual change was (.*)/
+                    Termline::Style.colorize(" #{Termline::Style.icon(:warning)}  #{msg}", :yellow)
+
+                # 4. Collection/Count Failures (e.g., Expected 5 elements, found 2)
+                when /Expected (.*) elements?, found (.*)/, /Expected exactly (.*) nodes/
+                    Termline::Style.colorize(" #{Termline::Style.icon(:list)}  #{msg}", :magenta)
+
+                # 5. Fallback for custom messages (anything else)
+                else
+                    Termline::Style.colorize(" #{Termline::Style.icon(:arrow_right)}  #{msg}", :gray)
+                end
+            end
         end
     end
 end

data/lib/lesli_testing/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module LesliTesting
-  VERSION = "1.2.1"
-  BUILD = "1774404580"
+  VERSION = "1.2.3"
+  BUILD = "1775000800"
 end

data/lib/lesli_testing.rb

@@ -31,6 +31,7 @@
 
 #
 require_relative "lesli_testing/version"
+require "termline" unless defined?(Termline)
 
 module LesliTesting
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lesli_testing
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.3
 platform: ruby
 authors:
 - The Lesli Development Team
@@ -93,6 +93,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.10.0
+- !ruby/object:Gem::Dependency
+  name: termline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
 description: "Core testing utilities for the Lesli Platform, providing standardized
   Minitest configuration, \ncoverage setup, and shared testing conventions across
   engines and applications.\n"
@@ -105,6 +119,7 @@ files:
 - lib/lesli_testing.rb
 - lib/lesli_testing/config.rb
 - lib/lesli_testing/coverage.rb
+- lib/lesli_testing/engine.rb
 - lib/lesli_testing/helpers/response_integration_helper.rb
 - lib/lesli_testing/loader.rb
 - lib/lesli_testing/reporters/cli_reporter.rb