ace-test-runner 0.18.0

data/lib/ace/test_runner/molecules/failure_analyzer.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Molecules
+      # Analyzes test failures and provides insights
+      class FailureAnalyzer
+        COMMON_PATTERNS = {
+          assertion: {
+            pattern: /Expected: (.+)\n\s+Actual: (.+)/m,
+            suggestion: "Check the assertion values. Expected and actual don't match."
+          },
+          nil_error: {
+            pattern: /undefined method .+ for nil:NilClass/,
+            suggestion: "Object is nil. Add nil check or ensure object is initialized."
+          },
+          missing_constant: {
+            pattern: /uninitialized constant (\S+)/,
+            suggestion: "Class or module not found. Check requires/imports or class name spelling."
+          },
+          argument_error: {
+            pattern: /wrong number of arguments \(given (\d+), expected (\d+)\)/,
+            suggestion: "Method called with wrong number of arguments. Check method signature."
+          },
+          file_not_found: {
+            pattern: /No such file or directory/,
+            suggestion: "File doesn't exist. Check file path or create the file."
+          },
+          syntax_error: {
+            pattern: /syntax error/,
+            suggestion: "Ruby syntax error. Check for missing brackets, quotes, or keywords."
+          },
+          timeout: {
+            pattern: /execution expired|timeout/i,
+            suggestion: "Operation timed out. Consider increasing timeout or optimizing slow code."
+          }
+        }.freeze
+
+        def analyze_failure(failure_data)
+          return failure_data unless failure_data.is_a?(Hash)
+
+          message = failure_data[:message] || failure_data[:full_content] || ""
+
+          # Try to extract test class and method
+          if failure_data[:test_name] && failure_data[:test_name].include?("#")
+            parts = failure_data[:test_name].split("#")
+            failure_data[:test_class] = parts[0]
+            failure_data[:test_name] = parts[1]
+          end
+
+          # Analyze the error message for common patterns
+          suggestion = find_suggestion(message)
+          failure_data[:fix_suggestion] = suggestion if suggestion
+
+          # Extract file and line from location if available
+          if failure_data[:location] && failure_data[:location].is_a?(Hash)
+            failure_data[:file_path] = failure_data[:location][:file]
+            failure_data[:line_number] = failure_data[:location][:line]
+          end
+
+          # Extract code context if file and line are available
+          if failure_data[:file_path] && failure_data[:line_number] && File.exist?(failure_data[:file_path])
+            failure_data[:code_context] = extract_code_context(
+              failure_data[:file_path],
+              failure_data[:line_number]
+            )
+          end
+
+          # Clean and format backtrace
+          if failure_data[:backtrace]
+            failure_data[:formatted_backtrace] = format_backtrace(failure_data[:backtrace])
+          end
+
+          Models::TestFailure.new(failure_data)
+        end
+
+        def analyze_all(failures, stderr: nil)
+          return [] unless failures.is_a?(Array)
+
+          failures.map do |failure|
+            analyzed = analyze_failure(failure)
+            # Associate stderr with all failures if present
+            analyzed.stderr_warnings = stderr if stderr && !stderr.empty?
+            analyzed
+          end
+        end
+
+        def group_by_type(failures)
+          failures.group_by(&:type)
+        end
+
+        def group_by_file(failures)
+          failures.group_by(&:file_path).compact
+        end
+
+        def find_common_issues(failures)
+          issues = {}
+
+          # Count occurrences of each type of error
+          failures.each do |failure|
+            COMMON_PATTERNS.each do |issue_type, config|
+              if failure.message&.match?(config[:pattern])
+                issues[issue_type] ||= {count: 0, failures: [], suggestion: config[:suggestion]}
+                issues[issue_type][:count] += 1
+                issues[issue_type][:failures] << failure
+              end
+            end
+          end
+
+          issues.sort_by { |_, v| -v[:count] }.to_h
+        end
+
+        def generate_fix_script(failures)
+          fixes = []
+
+          failures.each do |failure|
+            if failure.message&.match?(/DEPRECATION WARNING/)
+              fixes << generate_deprecation_fix(failure)
+            elsif failure.message&.match?(/undefined method/)
+              fixes << generate_method_fix(failure)
+            end
+          end
+
+          fixes.compact
+        end
+
+        def extract_code_context(file_path, line_number, radius = 5)
+          return nil unless File.exist?(file_path)
+
+          lines = File.readlines(file_path)
+          total_lines = lines.size
+          center_line = line_number.to_i
+
+          # Calculate the range of lines to include
+          start_line = [center_line - radius, 1].max
+          end_line = [center_line + radius, total_lines].min
+
+          context = {
+            file: file_path,
+            center_line: center_line,
+            lines: {}
+          }
+
+          (start_line..end_line).each do |line_num|
+            line_content = lines[line_num - 1]
+            context[:lines][line_num] = {
+              content: line_content.chomp,
+              highlighted: line_num == center_line
+            }
+          end
+
+          context
+        end
+
+        def format_backtrace(backtrace)
+          return [] unless backtrace
+
+          # Convert to array if it's a string
+          trace_lines = backtrace.is_a?(String) ? backtrace.split("\n") : backtrace
+
+          formatted = []
+          project_root = Dir.pwd
+
+          trace_lines.each do |line|
+            # Clean up the line
+            clean_line = line.strip
+
+            # Skip minitest internal frames unless in verbose mode
+            next if clean_line.include?("/minitest/") && !@verbose
+            next if clean_line.include?("/bundler/") && !@verbose
+
+            # Parse the backtrace line
+            if clean_line =~ /^(.+):(\d+):in `(.+)'$/
+              file = $1
+              line_num = $2
+              method = $3
+
+              # Make paths relative to project root
+              relative_file = file.start_with?(project_root) ?
+                file.sub(project_root + "/", "") : file
+
+              formatted << {
+                file: relative_file,
+                line: line_num.to_i,
+                method: method,
+                in_project: file.start_with?(project_root)
+              }
+            else
+              # Keep unparseable lines as-is
+              formatted << {raw: clean_line}
+            end
+          end
+
+          formatted
+        end
+
+        private
+
+        def find_suggestion(message)
+          COMMON_PATTERNS.each do |_, config|
+            return config[:suggestion] if message.match?(config[:pattern])
+          end
+
+          # Generic suggestions based on keywords
+          case message
+          when /permission denied/i
+            "Check file/directory permissions"
+          when /connection refused/i
+            "Service not running or wrong connection settings"
+          when /invalid/i
+            "Check input validation and data format"
+          when /not found/i
+            "Resource doesn't exist. Check paths and names"
+          end
+        end
+
+        def generate_deprecation_fix(failure)
+          {
+            file: failure.file_path,
+            line: failure.line_number,
+            type: :deprecation,
+            fix: extract_deprecation_fix(failure.message)
+          }
+        end
+
+        def generate_method_fix(failure)
+          if failure.message =~ /undefined method `(.+)' for/
+            method = $1
+            {
+              file: failure.file_path,
+              line: failure.line_number,
+              type: :missing_method,
+              fix: "Define method '#{method}' or check spelling"
+            }
+          end
+        end
+
+        def extract_deprecation_fix(message)
+          # Look for "use X instead" patterns
+          if message =~ /use (.+) instead/i
+            "Replace with: #{$1}"
+          else
+            "Update deprecated code"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/molecules/in_process_runner.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "ostruct"
+require "minitest"
+
+module Ace
+  module TestRunner
+    module Molecules
+      # Runs tests directly in the current Ruby process without spawning subprocesses
+      # This provides significantly faster execution for unit tests that don't need isolation
+      class InProcessRunner
+        def initialize(timeout: nil)
+          @timeout = timeout
+        end
+
+        def execute_tests(files, options = {})
+          return empty_result if files.empty?
+
+          start_time = Time.now
+
+          # Capture stdout/stderr
+          original_stdout = $stdout
+          original_stderr = $stderr
+          stdout_io = StringIO.new
+          stderr_io = StringIO.new
+
+          # Store original verbose setting
+          original_verbose = $VERBOSE
+          original_mt_no_autorun = ENV["MT_NO_AUTORUN"]
+
+          begin
+            $stdout = stdout_io
+            $stderr = stderr_io
+            $VERBOSE = nil if options[:suppress_warnings]
+
+            # Prevent Minitest from auto-running
+            ENV["MT_NO_AUTORUN"] = "1"
+
+            # Add test directory to load path if not already there
+            test_dir = File.expand_path("test")
+            lib_dir = File.expand_path("lib")
+            $LOAD_PATH.unshift(test_dir) unless $LOAD_PATH.include?(test_dir)
+            $LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
+            # Only require minitest/autorun if not already loaded
+            # This prevents double runs when ace/test_support is loaded
+            unless defined?(Minitest.autorun)
+              require "minitest/autorun"
+            end
+
+            # First pass: check for line numbers and resolve test names
+            # This must be done before loading files
+            test_names_to_run = []
+            files_to_load = []
+
+            files.each do |file|
+              # Check if file has line number (file:line format)
+              if file =~ /^(.+):(\d+)$/
+                actual_file = $1
+                line_number = $2.to_i
+
+                # Resolve line number to test name
+                require_relative "../atoms/line_number_resolver"
+                test_name = Ace::TestRunner::Atoms::LineNumberResolver.resolve_test_at_line(actual_file, line_number)
+                test_names_to_run << test_name if test_name
+
+                files_to_load << actual_file
+              else
+                files_to_load << file
+              end
+            end
+
+            # Store test names in options to pass to run_minitest_with_args
+            options = options.merge(test_names_filter: test_names_to_run) if test_names_to_run.any?
+
+            # Clear previously loaded test classes to avoid accumulation between groups
+            # This is crucial for in-process execution where tests from previous groups
+            # would otherwise be re-run in subsequent groups
+            Minitest::Runnable.runnables.clear
+
+            # Setup Minitest::Reporters BEFORE loading test files
+            # For in-process mode, we need to handle reporter state carefully
+            # because Minitest::Reporters.use! only works properly on first call
+            require "minitest/reporters"
+
+            # Create a fresh reporter for this group
+            reporter = Minitest::Reporters::DefaultReporter.new(io: $stdout)
+
+            # If this isn't the first group, we need to replace the existing reporter
+            if Minitest.reporter && Minitest.reporter.reporters
+              $stdout.flush
+              Minitest.reporter.reporters.clear
+              Minitest.reporter.reporters << reporter
+              # Reset reporter state for the new group
+              reporter.start_time = nil
+              # NOTE: Known limitation - progress dots don't show for subsequent groups
+              # in in-process mode. This appears to be a Minitest::Reporters limitation
+              # where some internal state prevents proper output after the first run.
+              # Test counts and results are still accurate.
+            else
+              # First group - use the standard setup
+              Minitest::Reporters.use! reporter
+            end
+
+            # Load the test files
+            files_to_load.uniq.each do |file|
+              file_path = File.expand_path(file)
+              begin
+                load file_path
+              rescue LoadError => e
+                stderr_io.puts "Failed to load #{file}: #{e.message}"
+                # Re-raise to fail the entire test run
+                raise
+              end
+            end
+
+            # Run Minitest with captured output
+            # Suppress Minitest's own output by using null reporter
+            exit_code = if @timeout
+              Timeout.timeout(@timeout) do
+                run_minitest_silent(options)
+              end
+            else
+              run_minitest_silent(options)
+            end
+
+            success = exit_code == true || exit_code == 0
+          rescue Timeout::Error
+            stderr_io.puts "Test execution timed out after #{@timeout} seconds"
+            success = false
+            exit_code = 124
+          rescue LoadError
+            # LoadError already logged in the loop above
+            stderr_io.puts "Test run aborted due to load error"
+            success = false
+            exit_code = 1
+          rescue => e
+            stderr_io.puts "Error running tests: #{e.message}"
+            stderr_io.puts e.backtrace.join("\n") if options[:verbose]
+            success = false
+            exit_code = 1
+          ensure
+            $stdout = original_stdout
+            $stderr = original_stderr
+            $VERBOSE = original_verbose
+
+            # Restore original MT_NO_AUTORUN value
+            if original_mt_no_autorun
+              ENV["MT_NO_AUTORUN"] = original_mt_no_autorun
+            else
+              ENV.delete("MT_NO_AUTORUN")
+            end
+          end
+
+          end_time = Time.now
+
+          {
+            stdout: stdout_io.string,
+            stderr: stderr_io.string,
+            status: OpenStruct.new(success?: success, exitstatus: if exit_code.is_a?(Integer)
+                                                                    exit_code
+                                                                  else
+                                                                    (success ? 0 : 1)
+                                                                  end),
+            command: "in-process:#{files.join(",")}",
+            start_time: start_time,
+            end_time: end_time,
+            duration: end_time - start_time,
+            success: success
+          }
+        end
+
+        def execute_single_file(file, options = {})
+          execute_tests([file], options)
+        end
+
+        def execute_with_progress(files, options = {}, &block)
+          # For in-process execution, we run all tests together for best performance
+          result = execute_tests(files, options)
+
+          # Send stdout event for per-test progress parsing
+          if block_given? && result[:stdout]
+            yield({type: :stdout, content: result[:stdout]})
+          end
+
+          # Simulate progress callbacks for compatibility
+          if block_given?
+            files.each { |file| yield({type: :start, file: file}) }
+            files.each { |file| yield({type: :complete, file: file, success: result[:success], duration: result[:duration] / files.size}) }
+          end
+
+          result
+        end
+
+        private
+
+        def empty_result
+          {
+            stdout: "",
+            stderr: "No test files found",
+            status: OpenStruct.new(success?: true, exitstatus: 0),
+            command: "",
+            start_time: Time.now,
+            end_time: Time.now,
+            duration: 0.0,
+            success: true
+          }
+        end
+
+        def run_minitest_with_args(options)
+          # Build Minitest arguments
+          args = []
+          args << "--seed" << options[:seed].to_s if options[:seed]
+          args << "--verbose" if options[:verbose]
+
+          # Add test name filter if line numbers were provided
+          if options[:test_names_filter] && options[:test_names_filter].any?
+            pattern = options[:test_names_filter].map { |name| Regexp.escape(name) }.join("|")
+            args << "--name" << "/#{pattern}/"
+          end
+
+          # Run Minitest
+          # Returns true on success, false on failure
+          Minitest.run(args)
+        end
+
+        def run_minitest_silent(options)
+          # Minitest uses reporters that can bypass $stdout redirection
+          # We need to suppress Minitest's own output completely
+
+          # Build Minitest arguments
+          args = []
+          args << "--seed" << options[:seed].to_s if options[:seed]
+
+          # Add test name filter if line numbers were provided
+          if options[:test_names_filter] && options[:test_names_filter].any?
+            pattern = options[:test_names_filter].map { |name| Regexp.escape(name) }.join("|")
+            args << "--name" << "/#{pattern}/"
+          end
+
+          # Reporter already set up before loading test files
+          # Run Minitest
+          Minitest.run(args)
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/molecules/package_resolver.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "ace/support/fs"
+
+module Ace
+  module TestRunner
+    module Molecules
+      # Resolves package names or paths to absolute package directories
+      # Supports: package name (ace-bundle), relative path (./ace-bundle), absolute path
+      #
+      # Note: This class depends on ace-support-fs which provides ProjectRootFinder.
+      class PackageResolver
+        # Initialize resolver
+        # @param project_root [String, nil] Override project root (for testing)
+        def initialize(project_root: nil)
+          @project_root = project_root || Ace::Support::Fs::Molecules::ProjectRootFinder.find
+        end
+
+        # Resolve a package name or path to an absolute directory path
+        # @param name_or_path [String] Package name, relative path, or absolute path
+        # @return [String, nil] Absolute path to package directory, or nil if not found
+        def resolve(name_or_path)
+          return nil if name_or_path.nil? || name_or_path.empty?
+
+          path = if absolute_path?(name_or_path)
+            resolve_absolute(name_or_path)
+          elsif relative_path?(name_or_path)
+            resolve_relative(name_or_path)
+          else
+            resolve_by_name(name_or_path)
+          end
+
+          # Validate the resolved path has a test directory
+          return nil unless path && valid_package?(path)
+
+          path
+        end
+
+        # List all available packages in the mono-repo.
+        # Results are memoized since filesystem glob operations are relatively expensive.
+        # @return [Array<String>] List of package names
+        def available_packages
+          return [] unless @project_root
+
+          @available_packages ||= Dir.glob(File.join(@project_root, "ace-*"))
+            .select { |path| File.directory?(path) && has_test_directory?(path) }
+            .map { |path| File.basename(path) }
+            .sort
+        end
+
+        # Get the project root
+        # @return [String, nil] Project root path
+        attr_reader :project_root
+
+        private
+
+        def absolute_path?(path)
+          path.start_with?("/")
+        end
+
+        def relative_path?(path)
+          path == "." || path == ".." || path.start_with?("./") || path.start_with?("../")
+        end
+
+        def resolve_absolute(path)
+          return nil unless Dir.exist?(path)
+
+          File.realpath(path)
+        end
+
+        def resolve_relative(path)
+          expanded = File.expand_path(path, Dir.pwd)
+          return nil unless Dir.exist?(expanded)
+
+          File.realpath(expanded)
+        end
+
+        def resolve_by_name(name)
+          return nil unless @project_root
+
+          # Try exact match first (ace-bundle)
+          exact_path = File.join(@project_root, name)
+          return File.realpath(exact_path) if Dir.exist?(exact_path)
+
+          # Try with ace- prefix (bundle -> ace-bundle)
+          prefixed_path = File.join(@project_root, "ace-#{name}")
+          return File.realpath(prefixed_path) if Dir.exist?(prefixed_path)
+
+          nil
+        end
+
+        def valid_package?(path)
+          return false unless Dir.exist?(path)
+
+          has_test_directory?(path)
+        end
+
+        def has_test_directory?(path)
+          test_dir = File.join(path, "test")
+          Dir.exist?(test_dir)
+        end
+      end
+    end
+  end
+end