lesli_testing 1.2.2 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 582a2365a947f562ffdbd75bfe09f5af077bb1309b12cd9adeb29c8886d13472
-  data.tar.gz: a73846f568ac913e621716a49273000631fbbb9255e40e74e59db3f49b2cd41c
+  metadata.gz: e1cf4a585e7dba931395ea96d8d0c34a5043d4d89f04ad76a54efa9bfd3859ca
+  data.tar.gz: 23ad0d2b61b1ae38c6eb564259f034a2c06cf577b8432a9d3ec061effd223bbc
 SHA512:
-  metadata.gz: 9ddde3d544c159212ddcaf4aae80e9f0cd1294165cae78de2dacda04a7a667bf208479a64c38b6d65c4872cdf5229935bfacc3bdd80b4db0dc1be9a66a7f9aed
-  data.tar.gz: a035d7f5b72ab485137995eeb8c70102c4ac5e2dd1220a590c40f9bd4732dcdbaadce35bc89f3689f7d103816078570cd053479c99dcb27c466e6e4dc209f920
+  metadata.gz: 6639e33ce003c35998736b06e908b8e8ff44b19a68e4d24978f4dcbb848c084313579d7c9a9b673591b7d3de21b7c5d3bd00a97664faa737c5f6ccb05e90f03a
+  data.tar.gz: d31df87681c091a836d4d6b1c7f77c6dbb8f76fb776d637ed5c628106c3c18241123845b5538dd45501b47ac66a572a263df1c7f4a68c644c8a3ab8fa82bcac8

data/lib/lesli_testing/config.rb

@@ -34,6 +34,21 @@ module LesliTesting
     module Config
         def self.apply(engine_module = nil)
 
+            if defined?(Lesli)
+                # Load fixtures from Lesli
+                if ActiveSupport::TestCase.respond_to?(:fixture_paths=)
+                    ActiveSupport::TestCase.fixture_paths = [ Lesli::Engine.root.join("test", "fixtures").to_s ]
+                    ActionDispatch::IntegrationTest.fixture_paths = ActiveSupport::TestCase.fixture_paths
+                    ActiveSupport::TestCase.file_fixture_path = Lesli::Engine.root.join("test", "fixtures", "files").to_s
+
+                    # IMPORTANT: attach fixture sets to namespaced models BEFORE loading fixtures
+                    ActiveSupport::TestCase.set_fixture_class(
+                        lesli_users:    "Lesli::User",
+                        lesli_accounts: "Lesli::Account"
+                    )
+                end
+            end
+
             # Load dummy app for unit testing
             # Run tests across all the engines: LESLI_INTEGRATION_TEST=true rails test
             # Run tests for the current engine: rails test
@@ -45,12 +60,6 @@ module LesliTesting
                     ActionDispatch::IntegrationTest.fixture_paths = ActiveSupport::TestCase.fixture_paths
                     ActiveSupport::TestCase.file_fixture_path = engine_module.root.join("test", "fixtures", "files").to_s
 
-                    # IMPORTANT: attach fixture sets to namespaced models BEFORE loading fixtures
-                    ActiveSupport::TestCase.set_fixture_class(
-                        lesli_users:    "Lesli::User",
-                        lesli_accounts: "Lesli::Account"
-                    )
-
                     ActiveSupport::TestCase.fixtures :all
                 end
             end

data/lib/lesli_testing/coverage.rb

@@ -42,7 +42,7 @@ module LesliTesting
             ])
 
             # Define the limit to allow missing tested code
-            SimpleCov::Formatter::Console.missing_len = 10
+            SimpleCov::Formatter::Console.missing_len = min_coverage
 
             SimpleCov.start "rails" do
                 command_name engine_name

data/lib/lesli_testing/loader.rb

@@ -40,11 +40,13 @@ require "simplecov-cobertura"
 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")
     Minitest.register_plugin("lesli_testing") 
 end
 
+
 # Load test configuration and test helper modules
 require_relative "coverage"
 require_relative "testers"
@@ -55,19 +57,26 @@ 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)
+            self.engine_module = engine_module
+        end
 
-            name = engine_module ? engine_module.name : "RailsApp"
+        def configure_coverage(options)
+
+            engine_name = self.engine_module ? self.engine_module.name : "RailsApp"
+
+            return if defined?(SimpleCov) && SimpleCov.running            
 
             # Start Coverage
-            LesliTesting::Coverage.start(name, options[:min_coverage] || 40)
-        end
+            LesliTesting::Coverage.start(engine_name, options[:min_coverage] || 40)
+        end 
 
-        def configure_tests!(engine_module = nil)
+        def configure_engine()
 
             # Apply Minitest/Reporters/Paths
-            LesliTesting::Config.apply(engine_module)
+            LesliTesting::Config.apply(self.engine_module)
         end
     end
 end

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)
+                ]
+
+                # Add execution time per test
+                parts << Termline::Style.colorize("(%.2fs)" % test.time, :red) if test.time > 1
 
-                puts(parts.compact.join(" ").strip)
+                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,7 +115,8 @@ module LesliTesting
                     failure_tag = failure.is_a?(Minitest::Assertion) ? "FAILURE" : "ERROR"
                     failure_msg = "#{result.class}##{result.name} (#{result.assertions} asserts)"
 
-                    location_file = "#{result.source_location.first} (line: #{result.source_location.second})"
+                    file, line = result.source_location
+                    location_file = file ? "#{file} (line: #{line})" : "Location unknown"
 
                     Termline.br
                     Termline.line(6)
@@ -116,6 +128,7 @@ module LesliTesting
                     if failure.is_a?(Minitest::Assertion)
                         result.failure.message.to_s.lines.each do |message|
                             puts(parse_minitest_assertion_messages(message))
+                            #puts(parse_minitest_assertion_messages2(message))
                         end
                     end
                 end
@@ -123,11 +136,75 @@ module LesliTesting
                 Termline.br
             end
 
-            def parse_minitest_assertion_messages 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)
+            def parse_minitest_assertion_messages(message)
+                message.to_s.rstrip.lines.map do |line|
+                    msg = line.strip
+
+                    case msg
+
+                        # 1. Unified Diff Headers
+                        # Covers Minitest diff output like:
+                        # --- expected
+                        # +++ actual
+                        # @@ -1 +1 @@
+                        when /^--- /
+                            Termline::Style.colorize("#{msg}:", :red)
+
+                        when /^\+\+\+ /
+                            Termline::Style.colorize("++#{msg}:", :green)
+
+                        when /^@@ / 
+                            Termline::Style.colorize("#{msg}", :skyblue)
+
+                        # 2. Unified Diff Content Lines
+                        # Covers actual changed lines inside the diff, like:
+                        # -[:lesli_support_item_tasks, "lesli_support"]
+                        # +[:lesli_support_items_tasks, "lesli_support"]
+                        # The negative lookahead avoids matching the diff headers above.
+                        when /^-(?!-)/
+                            Termline::Style.colorize(" #{Termline::Style.icon(:remove)}-#{msg}", :red)
+
+                        when /^\+(?!\+)/
+                            Termline::Style.colorize(" #{Termline::Style.icon(:add)}+#{msg}", :green)
+
+                        # 3. Boolean/Nil Failures
+                        # Covers cases like:
+                        # Expected true to be nil
+                        # Expected false to be truthy
+                        # Expected "abc" to be empty
+                        when /Expected (.*) to be (nil|truthy|falsey)/, /Expected (.*) to be (.*)/
+                            Termline::Style.colorize(" #{Termline::Style.icon(:info)}  #{msg}", :skyblue)
+
+                        # 4. Standard Expected vs Actual Output
+                        # Covers simple assertion output like:
+                        # Expected: 1
+                        # Actual: 2
+                        when /^Expected:?\s+/
+                            Termline::Style.colorize(" #{Termline::Style.icon(:add)}  #{msg}", :green)
+
+                        when /^Actual:?\s+/
+                            Termline::Style.colorize(" #{Termline::Style.icon(:remove)}    #{msg}", :red)
+
+                        # 5. Rails Difference Failures
+                        # Covers assertions like:
+                        # "User.count" didn't change by 1
+                        # actual change was 0
+                        when /"(.*)" didn't change by (.*)/, /actual change was (.*)/
+                            Termline::Style.colorize(" #{Termline::Style.icon(:warning)}  #{msg}", :yellow)
+
+                        # 6. Collection/Count Failures
+                        # Covers collection assertions like:
+                        # Expected 5 elements, found 2
+                        # Expected exactly 1 nodes
+                        when /Expected (.*) elements?, found (.*)/, /Expected exactly (.*) nodes/
+                            Termline::Style.colorize(" #{Termline::Style.icon(:list)}  #{msg}", :magenta)
+
+                        # 7. Fallback for Custom or Unrecognized Messages
+                        # Covers anything else not matched above.
+                        else 
+                            Termline::Style.colorize(" #{Termline::Style.icon(:arrow_right)}   #{msg}", :gray)
+                    end
+                end.join("\n")
             end
         end
     end

data/lib/lesli_testing/testers.rb

@@ -37,24 +37,29 @@ require_relative "helpers/response_integration_helper"
 #
 module LesliTesting
 
-    class IntegrationTester < ActionDispatch::IntegrationTest
-        include ResponseIntegrationHelper
+    if defined?(ActionDispatch::IntegrationTest)
+        class IntegrationTester < ActionDispatch::IntegrationTest
+            include ResponseIntegrationHelper
+        end
     end
 
-    class ViewTester < ActionView::TestCase
-        # We use a hook to include the helpers only when the class is used.
-        # This ensures Lesli core is fully loaded by Rails before we ask for the helpers.
-        def self.inherited(subclass)
-            super
-            subclass.class_eval do
-                include Lesli::HtmlHelper   if defined?(Lesli::HtmlHelper)
-                include Lesli::SystemHelper if defined?(Lesli::SystemHelper)
+    if defined?(ActionView::TestCase)
+        class ViewTester < ActionView::TestCase
+            # We use a hook to include the helpers only when the class is used.
+            # This ensures Lesli core is fully loaded by Rails before we ask for the helpers.
+            def self.inherited(subclass)
+                super
+                subclass.class_eval do
+                    include Lesli::HtmlHelper   if defined?(Lesli::HtmlHelper)
+                    include Lesli::SystemHelper if defined?(Lesli::SystemHelper)
+                end
             end
         end
     end
 
-    # Define the base classes inside the namespace
-    class ModelTester < ActiveSupport::TestCase
-        include ActiveSupport::Testing::TimeHelpers
+    if defined?(ActiveSupport::TestCase)
+        class ModelTester < ActiveSupport::TestCase
+            include ActiveSupport::Testing::TimeHelpers
+        end
     end
 end

data/lib/lesli_testing/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module LesliTesting
-  VERSION = "1.2.2"
-  BUILD = "1774678451"
+  VERSION = "1.2.4"
+  BUILD = "1775525290"
 end

data/lib/minitest/lesli_testing_plugin.rb

@@ -1,11 +1,11 @@
 require "lesli_testing/reporters/cli_reporter"
 
 module Minitest
-  def self.plugin_lesli_testing_options(opts, options)
-  end
+    def self.plugin_lesli_testing_options(opts, options)
+    end
 
-  def self.plugin_lesli_testing_init(options)
-    reporter.reporters.clear if reporter.respond_to?(:reporters)
-    reporter << LesliTesting::Reporters::CliReporter.new($stdout, options)
-  end
+    def self.plugin_lesli_testing_init(options)
+        reporter.reporters.clear if reporter.respond_to?(:reporters)
+        reporter << LesliTesting::Reporters::CliReporter.new($stdout, options)
+    end
 end

data/readme.md

@@ -10,11 +10,60 @@
 
 ### Quick start
 
+
+**Install LesliTesting gem**
+
 ```shell
-# Add LesliAdmin engine gem
 bundle add lesli_testing
 ```
 
+**Include LesliTesting in your rails/test/test_helper.rb**
+
+```ruby
+
+# load lesli testing tools
+require "lesli_testing/loader"
+
+
+# register engine for testing
+LesliTesting.configure(Lesli::Engine)
+
+
+# initialize coverage
+LesliTesting.configure_coverage({ :min_coverage => 10 })
+
+
+# Loading dummy app
+require_relative "../test/dummy/config/environment"
+ActiveRecord::Migrator.migrations_paths = [ File.expand_path("../test/dummy/db/migrate", __dir__) ]
+ActiveRecord::Migrator.migrations_paths << File.expand_path("../db/migrate", __dir__)
+require "rails/test_help"
+
+
+# configure tests
+LesliTesting.configure_engine()
+```
+
+**Run your tests D:**
+
+```shell
+rails test
+
+# or
+
+COVERAGE=true rails test
+```
+
+**Result :D**
+
+<div align="center">
+    <img
+        style="width:100%;max-width:800px;border-radius:6px;"
+        alt="LesliTesting screenshot" src="./docs/images/screenshot.png" />
+</div>
+
+<br />
+<br />
 
 ### Documentation
 * [website](https://www.lesli.dev/)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lesli_testing
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.4
 platform: ruby
 authors:
 - The Lesli Development Team