ace-test-runner 0.18.0

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

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative "base_formatter"
+
+module Ace
+  module TestRunner
+    module Formatters
+      # Progress formatter that shows one dot per test file (faster execution)
+      class ProgressFileFormatter < BaseFormatter
+        def initialize(options = {})
+          super
+          @test_count = 0
+          @line_width = options[:line_width] || 80
+          @configuration = options
+          @max_failures_to_display = options[:max_failures_to_display] || 7
+        end
+
+        def format_stdout(result)
+          lines = []
+
+          # Progress dots are printed during execution, ensure newline
+          lines << "" if @test_count > 0
+
+          # Report directory - use actual report path if available
+          if @report_path
+            lines << "Details: #{@report_path}/"
+          elsif @configuration && @configuration[:save_reports]
+            lines << "Details: #{@configuration[:report_dir] || ".ace-local/test/reports"}/latest/"
+          end
+
+          # Compact single-line summary with emoji status
+          status = if result.success?
+            "✅"
+          elsif result.errors > 0
+            "💥"
+          else
+            "❌"
+          end
+
+          summary = "#{status} #{result.total_tests} tests, #{result.assertions} assertions, " +
+            "#{result.failed} failures, #{result.errors} errors (#{format_duration(result.duration)})"
+          lines << summary
+
+          # Add failure details if there are any
+          if result.has_failures?
+            lines << ""
+            total_failures = result.failed + result.errors
+
+            # Display up to max_failures_to_display failures
+            failures_to_show = result.failures_detail.take(@max_failures_to_display)
+
+            # Show failure count header with reference to full report if needed
+            if total_failures > @max_failures_to_display
+              report_path = @report_path || "#{@configuration[:report_dir] || ".ace-local/test/reports"}/latest"
+              lines << "FAILURES (#{failures_to_show.size}/#{total_failures}) → #{report_path}/failures.json:"
+            else
+              lines << "FAILURES (#{total_failures}):"
+            end
+
+            failures_to_show.each_with_index do |failure, idx|
+              # Extract file and line from location (e.g., "/path/file.rb:42:in `test_method'")
+              if failure.location
+                location_match = failure.location.match(/^([^:]+):(\d+)/)
+                if location_match
+                  file = location_match[1].gsub(/^.*\/test\//, "test/")  # Shorten path
+                  line = location_match[2]
+                  location = "#{file}:#{line}"
+                else
+                  location = failure.location
+                end
+              else
+                location = failure.test_name || "unknown"
+              end
+
+              # Format: location - short message with individual failure report path
+              message = truncate_message(failure.message, 60)
+              lines << "  #{location} - #{message}"
+
+              # Show individual failure report path if we have the report path
+              if @report_path
+                failure_filename = format("%03d-%s.md", idx + 1,
+                  failure.full_test_name.gsub(/\W+/, "_").downcase[0...50])
+                lines << "  → Details: #{@report_path}/failures/#{failure_filename}"
+              end
+            end
+
+            # If there are more failures than displayed
+            if result.failures_detail.size > @max_failures_to_display
+              remaining = result.failures_detail.size - @max_failures_to_display
+              report_path = @report_path || "#{@configuration[:report_dir] || ".ace-local/test/reports"}/latest"
+              lines << "  ... and #{remaining} more #{(remaining == 1) ? "failure" : "failures"}. See full report: #{report_path}/failures.json"
+            end
+          end
+
+          lines.join("\n")
+        end
+
+        def format_report(report)
+          # For CI, keep the report simple and parseable
+          {
+            status: report.success? ? "success" : "failure",
+            stats: {
+              total: report.result.total_tests,
+              passed: report.result.passed,
+              failed: report.result.failed,
+              errors: report.result.errors,
+              skipped: report.result.skipped,
+              assertions: report.result.assertions,
+              duration: report.result.duration
+            },
+            failures: report.result.failures_detail.map { |f| failure_summary(f) }
+          }
+        end
+
+        def on_start(total_files)
+          # No verbose output in progress mode
+          @test_count = 0
+        end
+
+        def on_test_complete(file, success, duration)
+          # Print single character for each test file
+          char = if success
+            colorize(".", :green)
+          else
+            colorize("F", :red)
+          end
+
+          print char
+          @test_count += 1
+
+          # New line every N characters to prevent line overflow
+          puts if @test_count % @line_width == 0
+        end
+
+        def on_finish(result)
+          # Ensure we're on a new line
+          puts unless @test_count == 0 || @test_count % @line_width == 0
+          puts format_stdout(result)
+        end
+
+        private
+
+        def truncate_message(message, max_length = 100)
+          return "" unless message
+
+          msg = message.strip.tr("\n", " ")
+          if msg.length > max_length
+            "#{msg[0...max_length - 3]}..."
+          else
+            msg
+          end
+        end
+
+        def failure_summary(failure)
+          {
+            test: failure.full_test_name,
+            location: failure.location,
+            message: truncate_message(failure.message)
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,328 @@
+# frozen_string_literal: true
+
+require_relative "base_formatter"
+
+module Ace
+  module TestRunner
+    module Formatters
+      # Progress formatter that shows one dot per test (not per file)
+      class ProgressFormatter < BaseFormatter
+        def initialize(options = {})
+          super
+          @test_count = 0
+          @line_width = options[:line_width] || 80
+          @configuration = options
+          @max_failures_to_display = options[:max_failures_to_display] || 7
+          @test_results = []
+          @current_group = nil
+          @group_counts = Hash.new(0)
+          @files_by_group = Hash.new { |h, k| h[k] = [] }
+          @show_groups = options[:show_groups] != false
+        end
+
+        def format_stdout(result)
+          lines = []
+
+          # Progress dots are printed during execution, ensure newline
+          lines << "" if @test_count > 0
+
+          # Report directory - use actual report path if available
+          if @report_path
+            lines << "Details: #{@report_path}/"
+          elsif @configuration && @configuration[:save_reports]
+            lines << "Details: #{@configuration[:report_dir] || ".ace-local/test/reports"}/latest/"
+          end
+
+          # Compact single-line summary with emoji status
+          status = status_icon(result)
+
+          summary = "#{status} #{result.total_tests} tests, #{result.assertions} assertions, " +
+            "#{result.failed} failures, #{result.errors} errors"
+          summary += ", #{result.skipped} skipped" if result.has_skips?
+          summary += " (#{format_duration(result.duration)})"
+          lines << summary
+
+          # Add failure details if there are any
+          if result.has_failures?
+            lines << ""
+            total_failures = result.failed + result.errors
+
+            # Display up to max_failures_to_display failures
+            failures_to_show = result.failures_detail.take(@max_failures_to_display)
+
+            # Determine the label based on what types we have
+            failure_count = result.failures_detail.count { |f| f.type == :failure }
+            error_count = result.failures_detail.count { |f| f.type == :error }
+
+            label = if failure_count > 0 && error_count > 0
+              "FAILURES & ERRORS"
+            elsif error_count > 0
+              "ERRORS"
+            else
+              "FAILURES"
+            end
+
+            # Show failure count header with reference to full report if needed
+            if total_failures > @max_failures_to_display
+              report_path = @report_path || "#{@configuration[:report_dir] || ".ace-local/test/reports"}/latest"
+              lines << "#{label} (#{failures_to_show.size}/#{total_failures}) → #{report_path}/failures.json:"
+            else
+              lines << "#{label} (#{total_failures}):"
+            end
+
+            failures_to_show.each_with_index do |failure, idx|
+              # Extract file and line from location (e.g., "/path/file.rb:42:in `test_method'")
+              if failure.location
+                location_match = failure.location.match(/^([^:]+):(\d+)/)
+                if location_match
+                  file = location_match[1].gsub(/^.*\/test\//, "test/")  # Shorten path
+                  line = location_match[2]
+                  location = "#{file}:#{line}"
+                else
+                  location = failure.location
+                end
+              else
+                location = failure.test_name || "unknown"
+              end
+
+              # Format: location - short message with individual failure report path
+              message = truncate_message(failure.message, 60)
+              lines << "  #{location} - #{message}"
+
+              # Show individual failure report path if we have the report path
+              if @report_path
+                failure_filename = format("%03d-%s.md", idx + 1,
+                  failure.full_test_name.gsub(/\W+/, "_").downcase[0...50])
+                lines << "  → Details: #{@report_path}/failures/#{failure_filename}"
+              end
+            end
+
+            # If there are more failures than displayed
+            if result.failures_detail.size > @max_failures_to_display
+              remaining = result.failures_detail.size - @max_failures_to_display
+              report_path = @report_path || "#{@configuration[:report_dir] || ".ace-local/test/reports"}/latest"
+              lines << "  ... and #{remaining} more #{(remaining == 1) ? "failure" : "failures"}. See full report: #{report_path}/failures.json"
+            end
+          end
+
+          lines.join("\n")
+        end
+
+        def format_report(report)
+          # For CI, keep the report simple and parseable
+          {
+            status: report.success? ? "success" : "failure",
+            stats: {
+              total: report.result.total_tests,
+              passed: report.result.passed,
+              failed: report.result.failed,
+              errors: report.result.errors,
+              skipped: report.result.skipped,
+              assertions: report.result.assertions,
+              duration: report.result.duration
+            },
+            failures: report.result.failures_detail.map { |f| failure_summary(f) }
+          }
+        end
+
+        def on_start(total_files)
+          # No verbose output in progress mode
+          @test_count = 0
+          @test_results = []
+          @current_group = nil
+          @group_counts = Hash.new(0)
+          @total_files = total_files
+          @total_available = nil
+        end
+
+        def on_start_with_totals(files_to_run, total_available)
+          on_start(files_to_run)
+          @total_available = total_available
+
+          # Show file count if different from total available
+          if total_available && total_available > files_to_run
+            puts "Running #{files_to_run}/#{total_available} test files"
+            puts ""
+          end
+        end
+
+        def on_test_stdout(stdout)
+          # Parse individual test results from stdout
+          return unless stdout
+
+          # Look for test result lines in Minitest output
+          # Handles both plain and ANSI-colored output from Minitest::Reporters
+          stdout.each_line do |line|
+            # Match test result lines like:
+            # test_something [32m PASS[0m (0.00s)
+            # test_other [31m FAIL[0m (0.01s)
+            # test_error ERROR (0.00s)
+            # test_skip SKIP (0.00s)
+            # Improved regex to handle ANSI codes and underscores in test names
+            # ANSI codes are: \e[32m (color start), \e[0m (reset)
+            if line =~ /^\s*test_[\w_]+.*\s+(PASS|FAIL|ERROR|SKIP).*\([0-9.]+s\)/
+              result = case $1
+              when "PASS"
+                "."
+              when "FAIL"
+                "F"
+              when "ERROR"
+                "E"
+              when "SKIP"
+                "S"
+              else
+                "."
+              end
+
+              print colorize(result, result_color(result))
+              @test_count += 1
+              @test_results << result
+
+              # New line every N characters to prevent line overflow
+              puts if @test_count % @line_width == 0
+            end
+          end
+        end
+
+        def on_test_complete(file, success, duration)
+          # Detect group from file path
+          group = detect_group(file)
+
+          # Print group header if it's a new group and groups are enabled
+          if @show_groups && group != @current_group
+            puts unless @test_count == 0
+            puts ""
+            puts colorize("═══ #{group.to_s.capitalize} Tests ═══", :cyan)
+            @current_group = group
+            @test_count = 0  # Reset count for new line
+          end
+
+          # For per-test progress, we handle output in on_test_stdout if available
+          # Otherwise fall back to per-file dots
+          if @test_results.empty?
+            # No per-test output received, show file-level dot
+            char = success ? colorize(".", :green) : colorize("F", :red)
+            print char
+            @test_count += 1
+            puts if @test_count % @line_width == 0
+          end
+
+          # Track group counts
+          @group_counts[group] += 1 if @show_groups
+        end
+
+        def detect_group(file_path)
+          case file_path
+          when /test\/unit\/atoms\//
+            :atoms
+          when /test\/unit\/molecules\//
+            :molecules
+          when /test\/unit\/organisms\//
+            :organisms
+          when /test\/unit\/models\//
+            :models
+          when /test\/integration\//
+            :integration
+          when /test\/system\//
+            :system
+          else
+            :other
+          end
+        end
+
+        def on_group_start(group_name, file_count)
+          # Print visual separator before group
+          puts "" unless @test_count == 0
+          puts ""
+          puts "Running #{group_name} (#{file_count} #{(file_count == 1) ? "file" : "files"})..."
+          @test_count = 0
+        end
+
+        def on_group_complete(group_name, success, duration, summary)
+          # Ensure we're on a new line after dots
+          puts unless @test_count == 0 || @test_count % @line_width == 0
+
+          # Show group completion status
+          status_icon = success ? "✓" : "✗"
+          test_count = summary[:runs] || 0
+          failure_count = summary[:failures] || 0
+
+          status_line = "#{status_icon} #{group_name} complete " +
+            "(#{format_duration(duration)}, #{test_count} tests, #{failure_count} failures)"
+
+          puts colorize(status_line, success ? :green : :red)
+          puts ""
+        end
+
+        def on_finish(result)
+          # Ensure we're on a new line
+          puts unless @test_count == 0 || @test_count % @line_width == 0
+
+          # Print group summary if we have groups and groups are enabled
+          if @show_groups && @group_counts.any?
+            puts ""
+            puts colorize("═══ Group Summary ═══", :cyan)
+            @group_counts.each do |group, count|
+              puts "  #{group.to_s.capitalize}: #{count} #{(count == 1) ? "file" : "files"}"
+            end
+          end
+
+          puts format_stdout(result)
+        end
+
+        private
+
+        # Determines the appropriate status icon based on test results
+        # Returns ⚠️ for successful tests with skips (informational)
+        # Returns ✅ for successful tests without skips
+        # Returns 💥 for tests with errors
+        # Returns ❌ for tests with failures
+        def status_icon(result)
+          if result.success? && !result.has_skips?
+            "✅"
+          elsif result.success? && result.has_skips?
+            "⚠️"
+          elsif result.errors > 0
+            "💥"
+          else
+            "❌"
+          end
+        end
+
+        def result_color(result)
+          case result
+          when "."
+            :green
+          when "F"
+            :red
+          when "E"
+            :yellow
+          when "S"
+            :cyan
+          else
+            :default
+          end
+        end
+
+        def truncate_message(message, max_length = 100)
+          return "" unless message
+
+          msg = message.strip.tr("\n", " ")
+          if msg.length > max_length
+            "#{msg[0...max_length - 3]}..."
+          else
+            msg
+          end
+        end
+
+        def failure_summary(failure)
+          {
+            test: failure.full_test_name,
+            location: failure.location,
+            message: truncate_message(failure.message)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/models/test_configuration.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Models
+      # Configuration for test execution
+      class TestConfiguration
+        attr_accessor :format, :report_dir, :save_reports, :fail_fast,
+          :verbose, :filter, :fix_deprecations, :patterns,
+          :timeout, :parallel, :color, :per_file, :groups,
+          :target, :config_path, :failure_limits, :profile,
+          :execution, :files, :run_in_single_batch
+
+        def initialize(attributes = {})
+          @format = attributes[:format] || "progress"  # Default to per-test progress
+          @report_dir = attributes[:report_dir] || ".ace-local/test/reports"
+          @save_reports = attributes.fetch(:save_reports, true)
+          @fail_fast = attributes[:fail_fast] || false
+          @verbose = attributes[:verbose] || false
+          @filter = attributes[:filter]
+          @fix_deprecations = attributes[:fix_deprecations] || false
+          @patterns = attributes[:patterns] || default_patterns
+          @groups = attributes[:groups] || default_groups
+          @target = attributes[:target]
+          @config_path = attributes[:config_path]
+          @timeout = attributes[:timeout]  # In seconds, nil = no timeout
+          @parallel = attributes[:parallel] || false
+          @color = attributes.fetch(:color, true)
+          @per_file = attributes[:per_file] || false  # Default to grouped execution for performance
+          @failure_limits = attributes[:failure_limits] || {max_display: 7}
+          @profile = attributes[:profile]  # nil means no profiling, number means show N slowest tests
+          @execution = attributes[:execution] || {}
+          @files = attributes[:files]  # Specific files to test (overrides target/patterns)
+          @run_in_single_batch = attributes[:run_in_single_batch] || false
+        end
+
+        def valid_format?
+          %w[json progress progress-file].include?(format)
+        end
+
+        def validate!
+          unless valid_format?
+            raise ArgumentError, "Unknown format '#{format}'. Valid formats: progress, progress-file, json"
+          end
+
+          if save_reports && !writable_directory?(report_dir)
+            raise ArgumentError, "Cannot write to #{report_dir}. Check permissions"
+          end
+
+          # Validate execution_mode if provided
+          if execution_mode && !%w[grouped all-at-once].include?(execution_mode)
+            raise ArgumentError, "Unknown execution_mode '#{execution_mode}'. Valid modes: grouped, all-at-once"
+          end
+
+          true
+        end
+
+        def execution_mode
+          # Default to "all-at-once" for simple, fast execution
+          @execution&.[](:mode) || @execution&.dig("mode") || "all-at-once"
+        end
+
+        def group_isolation
+          # Default to true for better isolation in grouped mode
+          # Use fetch to handle false values correctly (|| would treat false as falsy)
+          mode = @execution&.[](:group_isolation)
+          mode = @execution&.dig("group_isolation") if mode.nil?
+          mode.nil? || mode
+        end
+
+        def formatter_class
+          # Use lazy loader to load formatter on demand
+          Atoms::LazyLoader.load_formatter(format)
+        end
+
+        def to_h
+          {
+            format: format,
+            report_dir: report_dir,
+            save_reports: save_reports,
+            fail_fast: fail_fast,
+            verbose: verbose,
+            filter: filter,
+            fix_deprecations: fix_deprecations,
+            patterns: patterns,
+            groups: groups,
+            target: target,
+            config_path: config_path,
+            timeout: timeout,
+            parallel: parallel,
+            color: color,
+            per_file: per_file,
+            failure_limits: failure_limits,
+            profile: profile,
+            execution: execution,
+            files: files,
+            run_in_single_batch: run_in_single_batch
+          }
+        end
+
+        def merge(options)
+          self.class.new(to_h.merge(options))
+        end
+
+        def self.from_file(path)
+          return new unless File.exist?(path)
+
+          config_data = YAML.load_file(path)
+          test_config = config_data["test"] || {}
+          new(test_config.transform_keys(&:to_sym))
+        end
+
+        def self.from_cascade
+          # Use ace-core configuration cascade if available
+          if defined?(Ace::Core::Configuration)
+            config = Ace::Core::Configuration.new
+            test_config = config.get("test", {})
+            new(test_config.transform_keys(&:to_sym))
+          else
+            new
+          end
+        end
+
+        private
+
+        def default_patterns
+          {
+            atoms: "test/unit/atoms/**/*_test.rb",
+            molecules: "test/unit/molecules/**/*_test.rb",
+            organisms: "test/unit/organisms/**/*_test.rb",
+            models: "test/unit/models/**/*_test.rb",
+            integration: "test/integration/**/*_test.rb",
+            system: "test/system/**/*_test.rb",
+            all: "test/**/*_test.rb"
+          }
+        end
+
+        def default_groups
+          {
+            unit: %w[atoms molecules organisms models],
+            all: %w[unit integration system],
+            quick: %w[atoms molecules]
+          }
+        end
+
+        def writable_directory?(dir)
+          if Dir.exist?(dir)
+            File.writable?(dir)
+          else
+            nearest_existing = dir
+            loop do
+              parent = File.dirname(nearest_existing)
+              break if parent == nearest_existing
+
+              nearest_existing = parent
+              break if Dir.exist?(nearest_existing)
+            end
+
+            Dir.exist?(nearest_existing) && File.writable?(nearest_existing)
+          end
+        end
+      end
+    end
+  end
+end