lesli_testing 1.4.1 → 1.4.2

data/lib/lesli_testing/minitest/cli_reporter.rb

@@ -30,34 +30,37 @@ Building a better future, one line of code at a time.
 // · 
 =end
 
+require_relative "../environment"
+
 module LesliTesting
     module Reporters
-        class CliReporter < Minitest::StatisticsReporter
+        # Inheriting from SummaryReporter is important even though LesliTesting
+        # renders its own summary. Minitest uses this type to detect a filtered
+        # run in which no tests matched and return a non-zero exit status.
+        class CliReporter < Minitest::SummaryReporter
             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)
-                )
+                run_statistics_reporter(:start)
 
-                Termline.br 2
+                io.puts
+                header_messages.each do |message|
+                    io.puts Termline::Style.colorize(message, :blue)
+                end
+                io.puts
+                io.puts
             end
 
             def record(test)
                 super
 
                 # Only print the line if the configuration allows it
-                return if ENV["QUIET"]
+                return if LesliTesting::Environment.enabled?("QUIET")
 
                 # Map result codes to styles
-                status_map = { 
-                    "." => [:green, "PASS"], 
-                    "S" => [:yellow, "SKIP"], 
-                    "E" => [:red, "ERROR"], 
+                status_map = {
+                    "." => [:green, "PASS"],
+                    "S" => [:yellow, "SKIP"],
+                    "W" => [:yellow, "WARN"],
+                    "E" => [:red, "ERROR"],
                     "F" => [:red, "FAIL"]
                 }
                 color, label = status_map[test.result_code] || [:gray, "????"]
@@ -82,85 +85,192 @@ module LesliTesting
                 # Add execution time per test
                 parts << Termline::Style.colorize("(%.2fs)" % test.time, :red) if test.time > 1
 
-                puts(parts.join(" "))
+                io.puts(parts.join(" "))
             end
 
             def report
-                super
+                run_statistics_reporter(:report)
 
                 total_tests = count.to_i
                 total_failures = failures.to_i
                 total_errors = errors.to_i
+                total_warnings = warnings.to_i
                 total_skips = skips.to_i
                 total_assertions = assertions.to_i
                 duration = total_time.to_f
 
-                passed = total_tests - total_failures - total_errors - total_skips
+                passed = total_tests - total_failures - total_errors - total_warnings - total_skips
                 success_rate = total_tests.zero? ? 0 : ((passed.to_f / total_tests) * 100).round(1)
-                status = (total_failures.zero? && total_errors.zero?) ? "PASS" : "FAIL"
+                empty_filtered_run = total_tests.zero? && options[:include]
+                status = if empty_filtered_run || total_failures.positive? || total_errors.positive? || total_warnings.positive?
+                    "FAIL"
+                else
+                    "PASS"
+                end
 
-                Termline.br 2
+                io.puts
+                io.puts
+
+                status_color = status == "FAIL" ? :red : :blue
+                failures_color = total_failures.positive? ? :red : :blue
+                errors_color = total_errors.positive? ? :red : :blue
+                warnings_color = total_warnings.positive? ? :yellow : :blue
+                success_rate_color = status == "FAIL" ? :red : :blue
+
+                write_summary_row(status,                    tag: "STATUS . . . . . . . :", color: status_color)
+                write_summary_row(total_tests,               tag: "TESTS. . . . . . . . :")
+                write_summary_row(passed,                    tag: "PASSED . . . . . . . :")
+                write_summary_row(total_failures,            tag: "FAILURES . . . . . . :", color: failures_color)
+                write_summary_row(total_errors,              tag: "ERRORS . . . . . . . :", color: errors_color)
+                write_summary_row(total_warnings,            tag: "WARNINGS . . . . . . :", color: warnings_color)
+                write_summary_row(total_skips,               tag: "SKIPPED. . . . . . . :")
+                write_summary_row(total_assertions,          tag: "ASSERTIONS . . . . . :")
+                write_summary_row("#{success_rate}%",        tag: "SUCCESS RATE . . . . :", color: success_rate_color)
+                write_summary_row(format("%.2fs", duration), tag: "TIME . . . . . . . . :")
+
+                io.puts
+                io.puts
+
+                if empty_filtered_run
+                    write_status_message(
+                        "No tests matched filter: #{options[:include]}",
+                        tag: "FAILURE",
+                        color: :red,
+                        icon: :error
+                    )
+                elsif status == "PASS"
+                    write_status_message("Test suite passed", tag: "SUCCESS:", color: :green, icon: :success)
+                else
+                    write_status_message("Test suite failed", tag: "FAILURE", color: :red, icon: :error)
+                end
 
-                status_color = :blue
-                status_color = :red if status == 'FAIL'
+                io.puts
+                io.puts
 
-                failures_color = :blue
-                failures_color = :red if total_failures > 0
+                print_result_details if total_failures.positive? || total_errors.positive? || total_warnings.positive? || total_skips.positive?
+
+            end
 
-                puts(Termline::Msg.builder(status,                   tag:'STATUS . . . . . . . :', color: status_color, timestamp:nil))
-                puts(Termline::Msg.builder(total_tests,              tag:'TESTS. . . . . . . . :', color: :blue, timestamp:nil))
-                puts(Termline::Msg.builder(passed,                   tag:'PASSED . . . . . . . :', color: :blue, timestamp:nil))
-                puts(Termline::Msg.builder(total_failures,           tag:'FAILURES . . . . . . :', color: failures_color, timestamp:nil))
-                puts(Termline::Msg.builder(total_errors,             tag:'ERRORS . . . . . . . :', color: :blue, timestamp:nil))
-                puts(Termline::Msg.builder(total_skips,              tag:'SKIPPED. . . . . . . :', color: :blue, timestamp:nil))
-                puts(Termline::Msg.builder(total_assertions,         tag:'ASSERTIONS . . . . . :', color: :blue, timestamp:nil))
-                puts(Termline::Msg.builder("#{success_rate}%",       tag:'SUCCESS RATE . . . . :', color: failures_color, timestamp:nil))
-                puts(Termline::Msg.builder(format("%.2fs", duration),tag:'TIME . . . . . . . . :', color: :blue, timestamp:nil))
+            private
+
+            # Skip SummaryReporter's default terminal output while reusing the
+            # statistics lifecycle implemented by its parent class.
+            def run_statistics_reporter(method_name)
+                Minitest::StatisticsReporter
+                    .instance_method(method_name)
+                    .bind(self)
+                    .call
+            end
 
-                Termline.br 2
+            def write_summary_row(value, tag:, color: :blue)
+                io.puts Termline::Msg.builder(value, tag: tag, color: color, time: false)
+            end
 
-                if status == "PASS"
-                    Termline.success("Test suite passed")
+            def header_messages
+                project_name = options[:lesli_testing_project_name]
+
+                case options[:lesli_testing_profile].to_s
+                when "app"
+                    [
+                        header_title(project_name, "Rails application"),
+                        "-> For a better result run tests over a clean database",
+                        "-> You can use: rake dev:db:rebuild"
+                    ]
+                when "engine"
+                    [
+                        header_title(project_name, "Rails engine"),
+                        "-> Tests run through the engine's Rails test application"
+                    ]
+                when "gem"
+                    [header_title(project_name, "Ruby gem")]
                 else
-                    Termline.danger("Test suite failed", tag:'FAILURE')
+                    ["Running Lesli tests..."]
                 end
+            end
 
-                Termline.br 2
-
-                print_failure_details if total_failures.positive? || total_errors.positive?
+            def header_title(project_name, project_type)
+                name = project_name.to_s.strip
+                return "Running tests for this #{project_type}..." if name.empty?
 
+                "Running tests for #{name} (#{project_type})..."
             end
 
-            private
+            def write_status_message(message, tag:, color:, icon:)
+                io.puts Termline::Msg.builder(message, tag: tag, icon: icon, color: color, time: true)
+            end
 
-            def print_failure_details
-                failed_results = Array(results).select { |result| result.failure }
+            def print_result_details
+                failed_results = Array(results).select(&:failure)
 
                 return if failed_results.empty?
 
                 failed_results.each_with_index do |result, index|
                     failure = result.failure
-                    failure_tag = failure.is_a?(Minitest::Assertion) ? "FAILURE" : "ERROR"
-                    failure_msg = "#{result.class}##{result.name} (#{result.assertions} asserts)"
+                    failure_tag, color, icon = result_style(failure)
+                    failure_msg = "#{result.klass}##{result.name} (#{result.assertions} asserts)"
+
+                    io.puts
+                    io.puts Termline::Space.builder("-·-     ", 6)
+                    io.puts
+
+                    io.puts Termline::Msg.builder(
+                        failure_msg,
+                        tag: " #{Termline::Style.icon(icon)} #{failure_tag} #{index + 1}:",
+                        color: color,
+                        time: false
+                    )
+                    io.puts Termline::Msg.builder(
+                        format_failure_location(failure),
+                        tag: " #{Termline::Style.icon(:debug)}  Location:",
+                        color: :yellow,
+                        time: false
+                    )
+
+                    print_result_message(failure)
+                end
 
-                    file, line = result.source_location
-                    location_file = file ? "#{file} (line: #{line})" : "Location unknown"
+                io.puts
+            end
 
-                    Termline.br
-                    Termline.line(6)
-                    Termline.br
+            def result_style(failure)
+                case failure
+                when Minitest::Skip
+                    ["SKIP", :yellow, :warning]
+                when Minitest::UnexpectedWarning
+                    ["WARNING", :yellow, :warning]
+                when Minitest::UnexpectedError
+                    ["ERROR", :red, :error]
+                else
+                    ["FAILURE", :red, :error]
+                end
+            end
 
-                    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)
+            def format_failure_location(failure)
+                location = failure.location.to_s
+                return "Location unknown" if location.empty? || location == "unknown:-1"
 
-                    if failure.is_a?(Minitest::Assertion)
-                        result.failure.message.to_s.lines.each do |message|
-                            puts(parse_minitest_assertion_messages(message))
-                        end
+                match = location.match(/\A(.+):(\d+)\z/)
+                return location unless match
+
+                "#{match[1]} (line: #{match[2]})"
+            end
+
+            def print_result_message(failure)
+                if failure.is_a?(Minitest::Skip)
+                    io.puts Termline::Style.colorize(
+                        " #{Termline::Style.icon(:warning)}  Reason: #{failure.message}",
+                        :yellow
+                    )
+                elsif failure.is_a?(Minitest::UnexpectedWarning)
+                    io.puts Termline::Style.colorize(
+                        " #{Termline::Style.icon(:warning)}  #{failure.message}",
+                        :yellow
+                    )
+                else
+                    failure.message.to_s.lines.each do |message|
+                        io.puts parse_minitest_assertion_messages(message)
                     end
                 end
-
-                Termline.br
             end
 
             def parse_minitest_assertion_messages(message)
@@ -175,10 +285,10 @@ module LesliTesting
                         # +++ actual
                         # @@ -1 +1 @@
                         when /^--- /
-                            Termline::Style.colorize("#{msg}:", :red)
+                            Termline::Style.colorize(msg, :red)
 
                         when /^\+\+\+ /
-                            Termline::Style.colorize("++#{msg}:", :green)
+                            Termline::Style.colorize(msg, :green)
 
                         when /^@@ / 
                             Termline::Style.colorize("#{msg}", :skyblue)
@@ -189,10 +299,10 @@ module LesliTesting
                         # +[: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)
+                            Termline::Style.colorize(" #{Termline::Style.icon(:remove)} #{msg}", :red)
 
                         when /^\+(?!\+)/
-                            Termline::Style.colorize(" #{Termline::Style.icon(:add)}+#{msg}", :green)
+                            Termline::Style.colorize(" #{Termline::Style.icon(:add)} #{msg}", :green)
 
                         # 3. Boolean/Nil Failures
                         # Covers cases like:
@@ -206,10 +316,10 @@ module LesliTesting
                         # Covers simple assertion output like:
                         # Expected: 1
                         # Actual: 2
-                        when /^Expected:?\s+/
+                        when /^Expected:\s+/
                             Termline::Style.colorize(" #{Termline::Style.icon(:add)}  #{msg}", :green)
 
-                        when /^Actual:?\s+/
+                        when /^Actual:\s+/
                             Termline::Style.colorize(" #{Termline::Style.icon(:remove)}    #{msg}", :red)
 
                         # 5. Rails Difference Failures
@@ -224,12 +334,12 @@ module LesliTesting
                         # 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)
+                            Termline::Style.colorize(" #{Termline::Style.icon(:info)}  #{msg}", :blue)
 
                         # 7. Fallback for Custom or Unrecognized Messages
                         # Covers anything else not matched above.
                         else 
-                            Termline::Style.colorize(" #{Termline::Style.icon(:arrow_right)}   #{msg}", :gray)
+                            Termline::Style.colorize(" #{Termline::Style.icon(:debug)}   #{msg}", :gray)
                     end
                 end.join("\n")
             end

data/lib/lesli_testing/rails_integration.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "active_support/lazy_load_hooks"
+require_relative "testers"
+require_relative "fixtures"
+
+module LesliTesting
+    module RailsIntegration
+        class << self
+            def install!(profile:, project_name:, engine_target: nil, options:)
+                LesliTesting::Fixtures.install!(
+                    profile: profile,
+                    engine_name: engine_target || project_name,
+                    options: options
+                )
+                install_engine!(engine_target || project_name) if profile == "engine"
+                LesliTesting::Testers.install!
+            end
+
+            private
+
+            def install_engine!(engine_target)
+                require "rails"
+                require "rails/engine"
+                require_relative "engine"
+
+                LesliTesting::Engine.configure(engine_target: engine_target)
+            end
+        end
+    end
+end

data/lib/lesli_testing/testers.rb

@@ -31,35 +31,83 @@ Building a better future, one line of code at a time.
 =end
 
 
-#
-require_relative "helpers/response_integration_helper"
-
-#
 module LesliTesting
+    module Testers
+        class << self
+            def install!
+                return if @installed
 
-    if defined?(ActionDispatch::IntegrationTest)
-        class IntegrationTester < ActionDispatch::IntegrationTest
-            include ResponseIntegrationHelper
-        end
-    end
+                ActiveSupport.on_load(
+                    :action_dispatch_integration_test,
+                    run_once: true,
+                    yield: true
+                ) do |test_case|
+                    define_integration_tester(test_case)
+                end
 
-    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)
+                ActiveSupport.on_load(
+                    :action_view_test_case,
+                    run_once: true,
+                    yield: true
+                ) do |test_case|
+                    define_view_tester(test_case)
                 end
+
+                ActiveSupport.on_load(
+                    :active_support_test_case,
+                    run_once: true,
+                    yield: true
+                ) do |test_case|
+                    define_model_tester(test_case)
+                    load_rails_test_cases
+                end
+
+                @installed = true
             end
-        end
-    end
 
-    if defined?(ActiveSupport::TestCase)
-        class ModelTester < ActiveSupport::TestCase
-            include ActiveSupport::Testing::TimeHelpers
+            private
+
+            def define_integration_tester(test_case)
+                return if LesliTesting.const_defined?(:IntegrationTester, false)
+
+                require_relative "helpers/response_integration_helper"
+
+                tester = Class.new(test_case) do
+                    include LesliTesting::ResponseIntegrationHelper
+                end
+                LesliTesting.const_set(:IntegrationTester, tester)
+            end
+
+            def define_view_tester(test_case)
+                return if LesliTesting.const_defined?(:ViewTester, false)
+
+                tester = Class.new(test_case) do
+                    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
+                LesliTesting.const_set(:ViewTester, tester)
+            end
+
+            def define_model_tester(test_case)
+                return if LesliTesting.const_defined?(:ModelTester, false)
+
+                require "active_support/testing/time_helpers"
+
+                tester = Class.new(test_case) do
+                    include ActiveSupport::Testing::TimeHelpers
+                end
+                LesliTesting.const_set(:ModelTester, tester)
+            end
+
+            def load_rails_test_cases
+                require "action_dispatch/testing/integration"
+                require "action_view/test_case"
+            end
         end
     end
 end

data/lib/lesli_testing/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module LesliTesting
-  VERSION = "1.4.1"
+  VERSION = "1.4.2"
   BUILD = "1791607001"
 end

data/lib/lesli_testing.rb

@@ -33,101 +33,17 @@ Building a better future, one line of code at a time.
 =end
 
 
-require_relative "lesli_testing/version"
-
-begin
-    require "rails/engine"
-    require_relative "lesli_testing/engine"
-rescue LoadError
-    # Rails is optional when LesliTesting is used by a standalone Ruby gem.
+# Coverage must begin before Ruby compiles the LesliTesting implementation,
+# Rails, or the project under test. The selected SimpleCov profile and
+# formatters are applied later by LesliTesting.app, LesliTesting.engine, or
+# LesliTesting.gem.
+# simplecov:disable
+require_relative "lesli_testing/environment"
+
+if LesliTesting::Environment.enabled?("COVERAGE")
+    require "coverage"
+    Coverage.start(lines: true) unless Coverage.running?
 end
 
-
-module LesliTesting
-    class Error < StandardError; end
-
-    class << self
-
-        attr_accessor :app_module; 
-        attr_accessor :app_name; 
-        attr_writer :options
-
-        def app(name, options = {})
-            configure(name, options.merge(coverage_profile: "app"))
-        end
-
-        def engine(name, options = {})
-            configure(name, options.merge(coverage_profile: "engine"))
-        end
-
-        def gem(name, options = {})
-            configure(name, options.merge(coverage_profile: "gem"))
-        end
-
-        private 
-
-        def options
-            @options ||= options_default
-        end
-
-        def options_default
-            {
-                coverage_profile: "app",
-                coverage_missing_len: 25,
-                coverage_min_coverage: 90
-            }
-        end
-
-        def configure(name, options)
-            self.app_name = name
-            self.options = options_default.merge(options)
-            configure_gems()
-            configure_reporter()
-            configure_coverage()
-            configure_fixtures()
-        end
-
-        def configure_coverage()
-
-            return unless ENV["COVERAGE"]
-            return if defined?(SimpleCov) && SimpleCov.running            
-
-            # Start Coverage
-            LesliTesting::Coverage.start(
-                self.app_name, 
-                profile: self.options[:coverage_profile],
-                missing_len: self.options[:coverage_missing_len],
-                min_coverage: self.options[:coverage_min_coverage]
-            )
-        end 
-
-        # Load test configuration and test helper modules
-        def configure_fixtures()
-            LesliTesting::Fixtures.load_fixtures_for_lesli()
-        end
-
-        def configure_reporter
-            # Force Minitest to know about Lesli Minitest reporter plugin
-            unless Minitest.extensions.include?("lesli_testing")
-                Minitest.register_plugin("lesli_testing") 
-            end
-        end
-
-        def configure_gems
-            return if @tools_loaded
-
-            require "minitest"
-
-            # Load minitest plugin
-            require "minitest/lesli_testing_plugin"
-            require "termline" unless defined?(Termline)
-
-            # Load helper files
-            require_relative "lesli_testing/testers"
-            require_relative "lesli_testing/fixtures"
-            require_relative "lesli_testing/coverage"
-
-            @tools_loaded = true
-        end
-    end
-end
+require_relative "lesli_testing/core"
+# simplecov:enable

data/lib/minitest/lesli_testing_plugin.rb

@@ -7,6 +7,10 @@ module Minitest
 
     def self.plugin_lesli_testing_init(options)
         reporter.reporters.clear if reporter.respond_to?(:reporters)
-        reporter << LesliTesting::Reporters::CliReporter.new($stdout, options)
+        reporter_options = options.merge(
+            lesli_testing_profile: LesliTesting.profile,
+            lesli_testing_project_name: LesliTesting.app_name
+        )
+        reporter << LesliTesting::Reporters::CliReporter.new(options[:io] || $stdout, reporter_options)
     end
 end