lesli_testing 1.4.1 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88698ef1e9d9deca5342518ce5b98a148f90fe3188598e8207555a379563ef36
-  data.tar.gz: 839d2855e41e179d6c50d5c62244c3edce13ebad39bd60039dae25886367d638
+  metadata.gz: 433531e6c20b86725f4e12ec00bc0cb90116c21b84f8a8c74a463f6ab94a2164
+  data.tar.gz: f621205f275fef7decb3c1ec25f3af9888d78b8204e1fd5bf002da6bed4aafd6
 SHA512:
-  metadata.gz: d5d712746d0f43f32991cc0823af12b1418f29c943f8eeddb1a97fc8f712d570b083e7a8b32617494a1c13617d29286e35fafab7dba7ea1cd5e46604cba52853
-  data.tar.gz: 1d60e86d118f5f8859cb5360d3fa01d5c3a35c0e47a087bcd461f224332c77a634322244aad8c08fbf567ce35ab960dcdd6e024bcbb082d584a8996bf9441dc7
+  metadata.gz: 67e13138ca3fd0a466cc9233884e763d3f686435f354ee9deab48890a3a71bb83279587921edaacc74a94757519051f6a7c4723a7a999380a2a744e20dd8f8e2
+  data.tar.gz: b7318e4af4ce796f07c3b2b6c458e3eb95c0f3a06a1bd598f397461f0a334d2d4a75e8a4ab1a2f98b99b89da97cd7b8d69c105d8240b00c67b640b2d0f6abc10

data/lib/lesli_testing/core.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+=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
+
+
+require_relative "version"
+require_relative "environment"
+
+
+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 = {})
+            engine_options = options.dup
+            engine_target = engine_options.delete(:engine) || name
+
+            configure(
+                name,
+                engine_options.merge(
+                    coverage_profile: "engine",
+                    engine_target: engine_target
+                )
+            )
+        end
+
+        def gem(name, options = {})
+            configure(name, options.merge(coverage_profile: "gem"))
+        end
+
+        def profile
+            @options && @options[:coverage_profile]
+        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_coverage()
+            configure_reporter()
+            configure_rails_integrations()
+        end
+
+        def configure_coverage()
+
+            return unless LesliTesting::Environment.enabled?("COVERAGE")
+            return if defined?(SimpleCov) && SimpleCov.started_in_this_process?
+
+            require_relative "coverage"
+
+            # 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
+
+        def configure_reporter
+            require "minitest"
+            require "termline" unless defined?(Termline)
+            require "minitest/lesli_testing_plugin"
+
+            # Force Minitest to know about Lesli Minitest reporter plugin
+            unless Minitest.extensions.include?("lesli_testing")
+                Minitest.register_plugin("lesli_testing")
+            end
+        end
+
+        def configure_rails_integrations
+            return if self.options[:coverage_profile] == "gem"
+
+            require_relative "rails_integration"
+            LesliTesting::RailsIntegration.install!(
+                profile: self.options[:coverage_profile],
+                project_name: self.app_name,
+                engine_target: self.options[:engine_target],
+                options: self.options
+            )
+        end
+    end
+end

data/lib/lesli_testing/coverage.rb

@@ -35,7 +35,6 @@ Building a better future, one line of code at a time.
 
 # Load code coverage tools
 require "simplecov"
-require "simplecov-html"
 require "simplecov-console"
 require "simplecov-cobertura"
 require_relative "simplecov/profiles"
@@ -50,7 +49,6 @@ module LesliTesting
                 # Add coverage formatters 
                 SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
                     SimpleCov::Formatter::CoberturaFormatter,
-                    SimpleCov::Formatter::HTMLFormatter,
                     SimpleCov::Formatter::Console
                 ])
 

data/lib/lesli_testing/engine.rb

@@ -32,35 +32,22 @@ Building a better future, one line of code at a time.
 
 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?
+        class << self
+            attr_reader :engine_target
 
-                # Lesli provides the shared schema required by every engine.
-                dependencies = ["Lesli"]
-
-                dependencies.each do |gem_name|
-                    begin
-                        # Find the constant for the gem's Engine
-                        gem_engine = "#{gem_name}::Engine".safe_constantize
+            def configure(engine_target:)
+                @engine_target = engine_target
+            end
+        end
 
-                        if gem_engine
-                            migration_path = gem_engine.root.join("db/migrate").to_s
+        initializer "lesli_testing.load_required_migrations", after: :load_config_initializers do |app|
+            next unless Rails.env.test?
+            next unless LesliTesting::Engine.engine_target
 
-                            # Append to the main app's migration paths if the directory exists
-                            if Dir.exist?(migration_path)
-                                registered_paths = app.config.paths["db/migrate"].expanded
-                                unless registered_paths.include?(migration_path)
-                                    app.config.paths["db/migrate"] << migration_path
-                                end
-                            end
-                        end
-                    rescue StandardError => e
-                        puts "LesliTesting: Could not load migrations for #{gem_name}: #{e.message}"
-                    end
-                end
-            end
+            LesliTesting::Fixtures.configure_migration_paths(
+                app,
+                engine_target: LesliTesting::Engine.engine_target
+            )
         end
     end
 end

data/lib/lesli_testing/environment.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+=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
+    module Environment
+        TRUE_VALUES = %w[true 1 yes].freeze
+
+        def self.enabled?(name, env: ENV)
+            TRUE_VALUES.include?(env[name].to_s.strip.downcase)
+        end
+    end
+end

data/lib/lesli_testing/fixtures.rb

@@ -32,40 +32,314 @@ Building a better future, one line of code at a time.
 
 module LesliTesting
     module Fixtures
+        LESLI_FIXTURE_CLASSES = {
+            lesli_users: "Lesli::User",
+            lesli_accounts: "Lesli::Account"
+        }.freeze
+
         class << self
-            def load_fixtures_for_lesli()
-
-                if defined?(Lesli)
-                    ActiveSupport.on_load(:active_support_test_case) do
-                        # En Rails 8, usamos ActiveRecord::TestFixtures si está disponible
-                        include ActiveRecord::TestFixtures if defined?(ActiveRecord::TestFixtures)
-
-                        lesli_fixtures = Lesli::Engine.root.join("test", "fixtures").to_s
-                        lesli_files = Lesli::Engine.root.join("test", "fixtures", "files").to_s
-
-                        # Rails 8 usa fixture_paths (plural) como el estándar
-                        # Pero para evitar el NoMethodError, lo asignamos de forma segura:
-                        if respond_to?(:fixture_paths=)
-                            # Combinamos las rutas existentes con la nueva del Engine
-                            self.fixture_paths |= [ lesli_fixtures ]
-                        else
-                            # Fallback por si la carga de ActiveRecord se retrasa
-                            class_attribute :fixture_paths, default: [ lesli_fixtures ]
-                        end
-
-                        # Los archivos adjuntos (Active Storage, etc)
-                        self.file_fixture_path = lesli_files
-
-                        # IMPORTANT: attach fixture sets to namespaced models BEFORE loading fixtures
-                        self.set_fixture_class(
-                            lesli_users:    "Lesli::User",
-                            lesli_accounts: "Lesli::Account"
-                        )
+            def install!(profile: "app", engine_name: nil, options: {})
+                @configuration = build_configuration(profile, engine_name, options)
+                return if @installed
+
+                ActiveSupport.on_load(
+                    :active_support_test_case,
+                    run_once: true,
+                    yield: true
+                ) do |test_case|
+                    configure_test_case(test_case, load_sets: true)
+                end
+
+                ActiveSupport.on_load(
+                    :action_dispatch_integration_test,
+                    run_once: true,
+                    yield: true
+                ) do |test_case|
+                    configure_test_case(test_case, load_sets: false)
+                end
+
+                ActiveSupport.on_load(
+                    :active_record,
+                    run_once: true,
+                    yield: true
+                ) do
+                    configure_migration_paths
+                end
+
+                @installed = true
+            end
+
+            def load_fixtures_for_engine(engine_module, test_case: nil)
+                test_case ||= ActiveSupport::TestCase if defined?(ActiveSupport::TestCase)
+                raise ArgumentError, "A Rails test case is required" unless test_case
+
+                configure_test_case(
+                    test_case,
+                    engine_module: engine_module,
+                    load_sets: true
+                )
+            end
+
+            def configure_migration_paths(application = nil, engine_target: nil)
+                configuration = @configuration
+                return [] unless configuration
+                return [] unless configuration[:profile] == "engine"
+                return [] unless configuration[:migrations][:enabled]
+                return [] unless test_environment?
+
+                application ||= Rails.application if defined?(Rails.application)
+                paths = migration_paths(application, engine_target: engine_target)
+
+                add_application_migration_paths(application, paths)
+                add_active_record_migration_paths(paths)
+
+                paths
+            end
+
+            private
+
+            def test_environment?
+                return false unless defined?(Rails)
+                return false unless Rails.respond_to?(:env)
+
+                Rails.env.respond_to?(:test?) && Rails.env.test?
+            end
+
+            def build_configuration(profile, engine_name, options)
+                fixture_options = options.fetch(:fixtures, {})
+                migration_options = options.fetch(:migrations, {})
+                default_shared = default_shared_engines(profile, engine_name)
+
+                {
+                    profile: profile,
+                    fixtures: build_fixture_configuration(
+                        fixture_options,
+                        profile,
+                        engine_name,
+                        default_shared
+                    ),
+                    migrations: build_migration_configuration(
+                        migration_options,
+                        engine_name,
+                        default_shared
+                    )
+                }
+            end
+
+            def build_fixture_configuration(options, profile, engine_name, default_shared)
+                return { enabled: false } if options == false
+
+                default_owner = engine_name if profile == "engine"
+                owner = options.fetch(:owner, default_owner)
+                shared = (default_shared + Array(options[:shared])).uniq
+                default_classes = if includes_lesli_fixtures?(owner, shared)
+                    LESLI_FIXTURE_CLASSES
+                else
+                    {}
+                end
+
+                {
+                    enabled: true,
+                    owner: owner,
+                    path: options[:path],
+                    file_path: options[:file_path],
+                    shared: shared,
+                    shared_paths: Array(options[:shared_paths]),
+                    sets: options.fetch(:sets, profile == "engine" ? :all : nil),
+                    classes: default_classes.merge(options.fetch(:classes, {}))
+                }
+            end
+
+            def build_migration_configuration(options, engine_name, default_shared)
+                return { enabled: false } if options == false
+
+                {
+                    enabled: true,
+                    owner: options.fetch(:owner, engine_name),
+                    owner_explicit: options.key?(:owner),
+                    include_dummy: options.fetch(:include_dummy, true),
+                    include_owner: options.fetch(:include_owner, true),
+                    shared: (default_shared + Array(options[:shared])).uniq,
+                    paths: Array(options[:paths])
+                }
+            end
+
+            def default_shared_engines(profile, engine_name)
+                return ["Lesli"] if profile == "app"
+                return [] unless profile == "engine"
+                return [] if ["Lesli", "Lesli::Engine"].include?(engine_name.to_s)
+
+                ["Lesli"]
+            end
+
+            def includes_lesli_fixtures?(owner, shared)
+                [owner, *shared].any? do |reference|
+                    ["Lesli", "Lesli::Engine"].include?(reference.to_s)
+                end
+            end
+
+            def configure_test_case(test_case, engine_module: nil, load_sets:)
+                configuration = @configuration
+                return [] unless configuration
+
+                fixture_configuration = configuration[:fixtures]
+                return [] unless fixture_configuration[:enabled]
+
+                owner_engine = engine_module || resolve_engine(fixture_configuration[:owner])
+                configured_paths = fixture_paths(owner_engine, fixture_configuration)
+
+                include_active_record_fixtures(test_case)
+                assign_fixture_paths(test_case, configured_paths, configuration[:profile])
+                assign_file_fixture_path(test_case, owner_engine, fixture_configuration)
+                configure_fixture_sets(test_case, fixture_configuration) if load_sets
+
+                configured_paths
+            end
+
+            def include_active_record_fixtures(test_case)
+                return unless defined?(ActiveRecord::TestFixtures)
+                return if test_case < ActiveRecord::TestFixtures
+
+                test_case.include(ActiveRecord::TestFixtures)
+            end
+
+            def fixture_paths(owner_engine, configuration)
+                paths = []
+                paths << expand_path(configuration[:path]) if configuration[:path]
+                paths << engine_path(owner_engine, "test", "fixtures") unless configuration[:path]
+
+                configuration[:shared].each do |shared_engine|
+                    paths << engine_path(resolve_engine(shared_engine), "test", "fixtures")
+                end
+
+                paths.concat(configuration[:shared_paths].map { |path| expand_path(path) })
+                paths.compact.uniq
+            end
+
+            def assign_fixture_paths(test_case, configured_paths, profile)
+                if test_case.respond_to?(:fixture_paths=)
+                    current_paths = if test_case.respond_to?(:fixture_paths)
+                        Array(test_case.fixture_paths)
+                    else
+                        []
+                    end
+
+                    paths = if profile == "engine"
+                        configured_paths + current_paths
+                    else
+                        current_paths + configured_paths
+                    end
+                    test_case.fixture_paths = paths.compact.uniq
+                elsif test_case.respond_to?(:class_attribute)
+                    test_case.class_attribute :fixture_paths, default: configured_paths
+                end
+            end
+
+            def assign_file_fixture_path(test_case, owner_engine, configuration)
+                return unless test_case.respond_to?(:file_fixture_path=)
+
+                file_path = configuration[:file_path]
+                file_path ||= engine_path(owner_engine, "test", "fixtures", "files") if owner_engine
+                test_case.file_fixture_path = expand_path(file_path) if file_path
+            end
+
+            def configure_fixture_sets(test_case, configuration)
+                if test_case.respond_to?(:set_fixture_class) && configuration[:classes].any?
+                    test_case.set_fixture_class(configuration[:classes])
+                end
+
+                sets = configuration[:sets]
+                return unless sets
+                return unless test_case.respond_to?(:fixtures)
+
+                sets == :all ? test_case.fixtures(:all) : test_case.fixtures(*Array(sets))
+            end
+
+            def migration_paths(application, engine_target: nil)
+                configuration = @configuration[:migrations]
+                paths = []
+
+                if configuration[:include_dummy] && application&.respond_to?(:root)
+                    paths << File.join(application.root.to_s, "db", "migrate")
+                end
+
+                if configuration[:include_owner]
+                    owner = if configuration[:owner_explicit]
+                        configuration[:owner]
+                    else
+                        engine_target || configuration[:owner]
                     end
+                    paths << engine_path(resolve_engine(owner), "db", "migrate")
+                end
+
+                configuration[:shared].each do |shared_engine|
+                    paths << engine_path(resolve_engine(shared_engine), "db", "migrate")
                 end
+
+                paths.concat(configuration[:paths].map { |path| expand_path(path) })
+                paths.compact.select { |path| Dir.exist?(path) }.uniq
+            end
+
+            def add_application_migration_paths(application, paths)
+                return unless application&.respond_to?(:config)
+
+                rails_paths = application.config.paths["db/migrate"]
+                return unless rails_paths
+
+                registered_paths = rails_paths.expanded.map { |path| expand_path(path) }
+                paths.each do |path|
+                    expanded_path = expand_path(path)
+                    next if registered_paths.include?(expanded_path)
+
+                    rails_paths << path
+                    registered_paths << expanded_path
+                end
+            end
+
+            def add_active_record_migration_paths(paths)
+                return unless defined?(ActiveRecord::Migrator)
+                return unless ActiveRecord::Migrator.respond_to?(:migrations_paths=)
+
+                current_paths = if ActiveRecord::Migrator.respond_to?(:migrations_paths)
+                    Array(ActiveRecord::Migrator.migrations_paths)
+                else
+                    []
+                end
+                registered_paths = current_paths.map { |path| expand_path(path) }
+                missing_paths = paths.reject do |path|
+                    registered_paths.include?(expand_path(path))
+                end
+
+                ActiveRecord::Migrator.migrations_paths = current_paths + missing_paths
+            end
+
+            def resolve_engine(reference)
+                return reference if reference.respond_to?(:root)
+                return if reference.nil?
+
+                constant = constantize(reference.to_s)
+                return constant if constant&.respond_to?(:root)
+                return unless constant&.const_defined?(:Engine)
+
+                constant.const_get(:Engine)
+            end
+
+            def constantize(name)
+                name.split("::").reject(&:empty?).inject(Object) do |namespace, constant_name|
+                    namespace.const_get(constant_name)
+                end
+            rescue NameError
+                nil
+            end
+
+            def engine_path(engine_module, *parts)
+                return unless engine_module&.respond_to?(:root)
+
+                File.join(engine_module.root.to_s, *parts)
             end
 
-            def load_fixtures_for_engine(engine_module)
+            def expand_path(path)
+                File.expand_path(path.to_s)
             end
         end
     end

data/lib/lesli_testing/helpers/response_integration_helper.rb

@@ -2,7 +2,7 @@
 
 Lesli
 
-Copyright (c) 2025, Lesli Technologies, S. A.
+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
@@ -30,17 +30,24 @@ Building a better future, one line of code at a time.
 // · 
 =end
 
-module ResponseIntegrationHelper
+require "json"
 
-    # return the body of a request response parsed as JSON
-    def response_json
-        JSON.parse(@response.body.blank? ? "{}" : @response.body) 
-    end
+module LesliTesting
+    module ResponseIntegrationHelper
+
+        # return the body of a request response parsed as JSON
+        def response_json(http_response = response)
+            JSON.parse(http_response.body.blank? ? "{}" : http_response.body)
+        end
 
+        def assert_successful_json_response(http_response = response)
+            assert_predicate(http_response, :successful?)
+            assert_equal("application/json", http_response.media_type)
+        end
 
-    # test a standard successful response for lesli 3
-    def expect_response_with_successful 
-        assert_response(:success)
-        assert_equal("application/json; charset=utf-8", @response.content_type)
+        # test a standard successful response for lesli 3
+        def expect_response_with_successful(http_response = response)
+            assert_successful_json_response(http_response)
+        end
     end
 end