ace-test-runner 0.18.0

data/lib/ace/test_runner/cli/commands/test.rb

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+require_relative "../../version"
+
+module Ace
+  module TestRunner
+    module CLI
+      module Commands
+        # ace-support-cli Command class for the test command
+        #
+        # This command runs tests with flexible package, target, and file selection.
+        # All business logic is inline in this single command class.
+        class Test < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc <<~DESC.strip
+            Run tests with flexible package, target, and file selection
+
+            SYNTAX:
+              ace-test [PACKAGE] [TARGET] [options] [files...]
+
+            PACKAGE (optional):
+              ace-*         Run tests in specified package (e.g., ace-bundle, ace-nav)
+              ./path        Run tests in package at relative path
+              /path         Run tests in package at absolute path
+
+            TARGETS:
+              atoms       Run atom tests only
+              molecules   Run molecule tests only
+              organisms   Run organism tests only
+              models      Run model tests only
+              unit        Run all unit tests (atoms + molecules + organisms + models)
+              integration Run integration tests
+              system      Run system tests
+              all         Run all tests (default)
+              quick       Run quick tests (atoms + molecules)
+
+            CONFIGURATION:
+              Global config:  ~/.ace/test-runner/config.yml
+              Project config: .ace/test-runner/config.yml
+              Example:        ace-test-runner/.ace-defaults/test-runner/config.yml
+
+              Can also use .ace/test-runner.yml for project-level config
+
+            OUTPUT:
+              By default, shows progress bar with summary
+              Use --format json for structured output
+              Reports saved to .ace-local/test/reports/<package>/ by default
+              Exit codes: 0 (pass), 1 (fail), 2 (error)
+
+            TEST HIERARCHY:
+              ATOM Architecture Test Layers:
+              - atoms       -> Pure functions (no side effects)
+              - molecules   -> Composed operations (controlled side effects)
+              - organisms   -> Business logic (complex coordination)
+              - models      -> Data structures (no behavior)
+              - integration -> Cross-component testing
+              - system      -> End-to-end workflows
+          DESC
+
+          # Examples shown in help output
+          example [
+            "                                    # All tests in current package",
+            "atoms                               # Atom tests only",
+            "ace-bundle molecules                # Package + target",
+            "test/foo_test.rb                    # Specific test file",
+            "--format progress                   # Run with progress output",
+            "--profile 10                        # Profile slowest tests",
+            "--fail-fast                         # Stop on first failure"
+          ]
+
+          # Output format options
+          option :format, type: :string, aliases: %w[-f], desc: "Output format: progress (default), progress-file, json"
+          option :report_dir, type: :string, aliases: %w[-d], desc: "Report root directory (default: .ace-local/test/reports)"
+          option :save_reports, type: :boolean, desc: "Skip saving detailed reports"
+
+          # Test execution options
+          option :fail_fast, type: :boolean, desc: "Stop execution on first failure"
+          option :fix_deprecations, type: :boolean, desc: "Auto-fix deprecated test patterns"
+          option :filter, type: :string, desc: "Run only tests matching pattern"
+          option :group, type: :string, aliases: %w[-g], desc: "Run specific test group (unit, integration, system, all)"
+          option :color, type: :boolean, desc: "Enable/disable colored output (default: enabled)"
+          option :config_path, type: :string, aliases: %w[-c], desc: "Configuration file path (default: .ace/test-runner.yml)"
+
+          # Type conversion options (ace-support-cli returns strings, need to convert to integers)
+          option :timeout, type: :string, desc: "Timeout for test execution in seconds"
+          option :max_display, type: :string, desc: "Maximum failures to display (default: 7)"
+          option :profile, type: :string, desc: "Show N slowest tests (default: 10)"
+
+          # Execution mode options
+          option :parallel, type: :boolean, desc: "Run tests in parallel (experimental)"
+          option :per_file, type: :boolean, desc: "Execute each test file separately (slower, for debugging)"
+          option :direct, type: :boolean, desc: "Force in-process execution (faster, less isolation)"
+          option :subprocess, type: :boolean, desc: "Force subprocess execution (slower, full isolation)"
+          option :run_in_sequence, type: :boolean, aliases: %w[--ris], desc: "Run test groups sequentially (default)"
+          option :run_in_single_batch, type: :boolean, aliases: %w[--risb], desc: "Run all tests together in single batch"
+
+          # Rake integration options
+          option :set_default_rake, type: :boolean, desc: "Set ace-test as default rake test runner"
+          option :unset_default_rake, type: :boolean, desc: "Remove ace-test as default rake test runner"
+          option :check_rake_status, type: :boolean, desc: "Check if ace-test is set as default rake test runner"
+
+          # Cleanup options
+          option :cleanup_reports, type: :boolean, desc: "Clean up old test reports (keeps last 10)"
+          option :cleanup_keep, type: :string, desc: "Number of reports to keep when cleaning (default: 10)"
+          option :cleanup_age, type: :string, desc: "Delete reports older than DAYS (default: 30)"
+
+          # Standard options (inherited from Base but need explicit definition for ace-support-cli)
+          option :version, type: :boolean, desc: "Show version information"
+          option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
+          option :verbose, type: :boolean, aliases: %w[-v], desc: "Show verbose output"
+          option :debug, type: :boolean, aliases: %w[-d], desc: "Show debug output"
+
+          def call(args: [], **options)
+            if options[:version]
+              puts "ace-test #{Ace::TestRunner::VERSION}"
+              return 0
+            end
+
+            # Type-convert numeric options (ace-support-cli returns strings, Thor converted to integers)
+            # This maintains parity with the Thor implementation
+            numeric_options = %i[timeout max_display profile cleanup_keep cleanup_age]
+            numeric_options.each do |key|
+              options[key] = options[key].to_i if options[key]
+            end
+
+            # Build test options with defaults
+            test_options = build_test_options(options)
+
+            # Display config summary
+            display_config_summary(test_options)
+
+            # Handle special modes first
+            result = handle_special_modes(args, test_options)
+            return result if result
+
+            # Parse CLI arguments using CliArgumentParser
+            begin
+              arg_parser = Molecules::CliArgumentParser.new(args)
+              parsed_args = arg_parser.parse
+              test_options.merge!(parsed_args)
+            rescue ArgumentError => e
+              raise Ace::Support::Cli::Error.new(e.message)
+            end
+
+            # Run tests with special exit! handling for Minitest compatibility
+            run_tests_with_exit_handling(test_options)
+          rescue Ace::TestRunner::Error => e
+            raise Ace::Support::Cli::Error.new(e.message)
+          rescue Interrupt
+            raise Ace::Support::Cli::Error.new("Test execution interrupted", exit_code: 130)
+          rescue => e
+            raise Ace::Support::Cli::Error.new("Unexpected error: #{e.message}")
+          end
+
+          private
+
+          def build_test_options(cli_options)
+            # Thor returns HashWithIndifferentAccess with string keys internally.
+            # Transform to symbol keys for consistent access patterns throughout the codebase.
+            symbolized_options = cli_options.transform_keys(&:to_sym)
+
+            # Handle mutually exclusive run mode options
+            # --run-in-sequence sets run_in_single_batch to false (default behavior)
+            # --run-in-single-batch sets run_in_single_batch to true
+            if symbolized_options[:run_in_sequence]
+              symbolized_options[:run_in_single_batch] = false
+            end
+            # Remove the run_in_sequence key as it's only used to set run_in_single_batch
+            symbolized_options.delete(:run_in_sequence)
+
+            # Default options - symbolized_options will override these for any explicit values
+            {
+              format: "progress",
+              save_reports: true,
+              verbose: false,
+              fail_fast: false,
+              fix_deprecations: false,
+              color: true,
+              per_file: false,
+              run_in_single_batch: false
+            }.merge(symbolized_options)
+          end
+
+          def handle_special_modes(args, options)
+            # Handle cleanup reports mode
+            if options[:cleanup_reports]
+              return handle_cleanup_reports(options)
+            end
+
+            # Handle rake integration modes
+            if options[:set_default_rake] || options[:unset_default_rake] || options[:check_rake_status]
+              return handle_rake_integration(options)
+            end
+
+            # Handle deprecation fixing mode
+            if options[:fix_deprecations]
+              return handle_fix_deprecations
+            end
+
+            nil # Continue to normal test execution
+          end
+
+          def handle_cleanup_reports(options)
+            require "ace/test_runner/molecules/report_storage"
+            require "ace/test_runner/atoms/timestamp_generator"
+            require "ace/test_runner/molecules/config_loader"
+
+            # Load config from cascade (ADR-022 pattern)
+            config_loader = Molecules::ConfigLoader.new
+            config_data = config_loader.load(options[:config_path])
+            config = config_loader.merge_with_options(config_data, options)
+
+            timestamp_generator = Atoms::TimestampGenerator.new
+            storage = Molecules::ReportStorage.new(
+              base_dir: config[:defaults][:report_dir] || ".ace-local/test/reports",
+              timestamp_generator: timestamp_generator
+            )
+
+            keep = options[:cleanup_keep] || 10
+            age = options[:cleanup_age] || 30
+
+            puts "Cleaning up test reports..."
+            puts "  Keeping last #{keep} reports"
+            puts "  Deleting reports older than #{age} days"
+
+            deleted = storage.cleanup_old_reports(keep: keep, max_age_days: age)
+
+            if deleted.empty?
+              puts "No reports to clean up."
+            else
+              puts "Deleted #{deleted.size} old reports:"
+              deleted.each { |path| puts "  - #{File.basename(path)}" }
+            end
+          end
+
+          def handle_rake_integration(options)
+            require "ace/test_runner/molecules/rake_integration"
+
+            integration = Molecules::RakeIntegration.new
+
+            if options[:set_default_rake]
+              result = integration.set_default
+              puts result[:message]
+              raise Ace::Support::Cli::Error.new(result[:message]) unless result[:success]
+              nil
+            elsif options[:unset_default_rake]
+              result = integration.unset_default
+              puts result[:message]
+              raise Ace::Support::Cli::Error.new(result[:message]) unless result[:success]
+              nil
+            elsif options[:check_rake_status]
+              status = integration.check_status
+              puts "Rake Test Integration Status:"
+              puts "  Rakefile exists: #{status[:rakefile_exists]}"
+              puts "  ace-test integrated: #{status[:integrated]}"
+              puts "  Message: #{status[:message]}"
+              puts "  Backup exists: #{status[:backup_exists]}" if status[:backup_exists]
+              puts "  Has test task: #{status[:has_test_task]}" if status.key?(:has_test_task)
+              nil
+            end
+          end
+
+          def handle_fix_deprecations
+            require "ace/test_runner/molecules/deprecation_fixer"
+
+            puts "Scanning for deprecated test patterns..."
+
+            detector = Atoms::TestDetector.new
+            fixer = Molecules::DeprecationFixer.new
+
+            test_files = detector.find_test_files
+            fixed_count = 0
+
+            test_files.each do |file|
+              result = fixer.fix_file(file, dry_run: false)
+              if result[:success] && result[:changes] > 0
+                puts "  Fixed #{result[:changes]} deprecations in #{file}"
+                fixed_count += result[:changes]
+              end
+            end
+
+            if fixed_count == 0
+              puts "No deprecations found to fix."
+            else
+              puts "Fixed #{fixed_count} deprecations total."
+            end
+          end
+
+          def run_tests_with_exit_handling(options)
+            exit_code = Ace::TestRunner.run(options)
+
+            # Flush IO buffers before exit! (which skips at_exit handlers including finalizers)
+            $stdout.flush
+            $stderr.flush
+
+            # IMPORTANT: Use exit! (not exit) to skip Ruby's at_exit handlers.
+            # This prevents Minitest from auto-running again via its at_exit hook.
+            # When ace-test uses in-process (direct) execution, test files are loaded
+            # into the current process. Minitest registers an at_exit handler that would
+            # re-run all tests on normal exit. Using exit! bypasses this.
+            # See guide://testable-code-patterns for details on this pattern.
+
+            # Note: We cannot use exit! here and return the exit code instead.
+            # The exe file wrapper will handle the exit! call.
+            exit_code
+          end
+
+          def display_config_summary(options)
+            return if options[:quiet]
+
+            require "ace/core"
+            Ace::Core::Atoms::ConfigSummary.display(
+              command: "test",
+              config: options,
+              defaults: {},
+              options: options,
+              quiet: false
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/cli.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+require "ace/core"
+require_relative "version"
+# Commands
+require_relative "cli/commands/test"
+
+module Ace
+  module TestRunner
+    # CLI namespace for ace-test-runner command classes.
+    module CLI
+      PROGRAM_NAME = "ace-test"
+    end
+  end
+end

data/lib/ace/test_runner/formatters/base_formatter.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Formatters
+      # Base class for all formatters
+      class BaseFormatter
+        attr_reader :options
+        attr_accessor :report_path
+
+        def initialize(options = {})
+          @options = options
+          @use_color = options.fetch(:color, true) && $stdout.tty?
+          @report_path = nil
+        end
+
+        # Format the test result for stdout output
+        def format_stdout(result)
+          raise NotImplementedError, "Subclasses must implement format_stdout"
+        end
+
+        # Format the complete report for saving
+        def format_report(report)
+          raise NotImplementedError, "Subclasses must implement format_report"
+        end
+
+        # Called when test execution starts
+        def on_start(total_files)
+          # Override in subclasses if needed
+        end
+
+        # Called when a single test file completes
+        def on_test_complete(file, success, duration)
+          # Override in subclasses if needed
+        end
+
+        # Called when all tests complete
+        def on_finish(result)
+          # Override in subclasses if needed
+        end
+
+        protected
+
+        def colorize(text, color)
+          return text unless @use_color
+
+          color_codes = {
+            red: "\e[31m",
+            green: "\e[32m",
+            yellow: "\e[33m",
+            blue: "\e[34m",
+            magenta: "\e[35m",
+            cyan: "\e[36m",
+            white: "\e[37m",
+            bold: "\e[1m",
+            reset: "\e[0m"
+          }
+
+          code = color_codes[color] || color_codes[:reset]
+          "#{code}#{text}#{color_codes[:reset]}"
+        end
+
+        def pluralize(count, singular, plural = nil)
+          plural ||= "#{singular}s"
+          (count == 1) ? "#{count} #{singular}" : "#{count} #{plural}"
+        end
+
+        def format_duration(seconds)
+          if seconds < 1
+            "#{(seconds * 1000).round(2)}ms"
+          elsif seconds < 60
+            "#{seconds.round(2)}s"
+          else
+            minutes = (seconds / 60).floor
+            remaining = (seconds % 60).round
+            "#{minutes}m #{remaining}s"
+          end
+        end
+
+        def success_icon
+          "✅"
+        end
+
+        def failure_icon
+          "❌"
+        end
+
+        def error_icon
+          "💥"
+        end
+
+        def skip_icon
+          "⚠️"
+        end
+
+        def format_percentage(value)
+          "#{value.round(1)}%"
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/formatters/json_formatter.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Formatters
+      # JSON formatter for machine-readable output
+      class JsonFormatter < BaseFormatter
+        def format_stdout(result)
+          # For JSON format, stdout gets the complete JSON
+          JSON.pretty_generate(format_result_hash(result))
+        end
+
+        def format_report(report)
+          # Complete report in JSON format
+          {
+            version: "1.0",
+            generator: "ace-test-runner",
+            timestamp: report.timestamp.iso8601,
+            environment: report.environment,
+            configuration: report.configuration.to_h,
+            summary: report.summary,
+            result: format_result_hash(report.result),
+            failures: format_failures_array(report.result.failures_detail),
+            deprecations: report.result.deprecations,
+            files_tested: report.files_tested,
+            metadata: report.metadata
+          }
+        end
+
+        def on_start(total_files)
+          # JSON formatter doesn't output progress
+        end
+
+        def on_test_complete(file, success, duration)
+          # JSON formatter doesn't output progress
+        end
+
+        def on_finish(result)
+          # Output complete JSON at the end
+          puts format_stdout(result)
+        end
+
+        private
+
+        def format_result_hash(result)
+          {
+            summary: {
+              passed: result.passed,
+              failed: result.failed,
+              errors: result.errors,
+              skipped: result.skipped,
+              total: result.total_tests,
+              assertions: result.assertions,
+              duration: result.duration,
+              pass_rate: result.pass_rate,
+              success: result.success?
+            },
+            timing: {
+              start_time: result.start_time&.iso8601,
+              end_time: result.end_time&.iso8601,
+              duration_seconds: result.duration,
+              duration_formatted: format_duration(result.duration)
+            },
+            failures: format_failures_array(result.failures_detail),
+            deprecations: result.deprecations
+          }
+        end
+
+        def format_failures_array(failures)
+          failures.map do |failure|
+            {
+              type: failure.type.to_s,
+              test_name: failure.test_name,
+              test_class: failure.test_class,
+              full_name: failure.full_test_name,
+              message: failure.message,
+              location: {
+                file: failure.file_path,
+                line: failure.line_number,
+                full: failure.location
+              },
+              fix_suggestion: failure.fix_suggestion,
+              backtrace: failure.backtrace
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/formatters/markdown_formatter.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "base_formatter"
+
+module Ace
+  module TestRunner
+    module Formatters
+      # Markdown formatter for generating individual failure report files
+      # This formatter is used internally for creating detailed failure reports
+      # It is not exposed as a user-selectable output format
+      class MarkdownFormatter < BaseFormatter
+        def initialize(options = {})
+          super
+          @configuration = options
+        end
+
+        # Generate markdown report for a single failure
+        def generate_failure_report(failure, index)
+          lines = []
+
+          # Title with status
+          status = failure.error? ? "ERROR" : "FAILURE"
+          lines << "# Test #{status}: #{failure.test_name}"
+          lines << ""
+          lines << "**Status:** #{status}"
+          lines << "**Location:** #{failure.location}" if failure.location
+          lines << ""
+
+          # Error Message
+          lines << "## Error Message"
+          lines << ""
+          lines << failure.message if failure.message
+          lines << ""
+
+          # Stack Trace
+          if failure.backtrace && !failure.backtrace.empty?
+            lines << "## Stack Trace"
+            lines << ""
+            lines << "```"
+            lines << failure.backtrace.take(15).join("\n")
+            lines << "```"
+            lines << ""
+          end
+
+          # Related stderr
+          if failure.stderr_warnings && !failure.stderr_warnings.empty?
+            lines << "## Related stderr"
+            lines << ""
+            lines << "```"
+            lines << failure.stderr_warnings
+            lines << "```"
+            lines << ""
+          end
+
+          # Code Context
+          if failure.code_context && failure.code_context[:lines]
+            lines << "## Code Context"
+            lines << ""
+            lines << "```ruby"
+            failure.code_context[:lines].each do |line_num, line_data|
+              marker = line_data[:highlighted] ? "← ERROR HERE" : ""
+              lines << format("%3d:  %s  %s", line_num, line_data[:content], marker)
+            end
+            lines << "```"
+            lines << ""
+          end
+
+          # Fix Suggestion
+          if failure.fix_suggestion
+            lines << "## Fix Suggestion"
+            lines << ""
+            lines << failure.fix_suggestion
+            lines << ""
+          end
+
+          lines.join("\n")
+        end
+
+        # Not used for console output
+        def format_stdout(result)
+          ""
+        end
+
+        # Not used for report generation
+        def format_report(report)
+          {}
+        end
+      end
+    end
+  end
+end