ace-test-runner 0.18.0

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Models
+      # Represents a single test failure or error
+      class TestFailure
+        attr_accessor :type, :test_name, :test_class, :message, :file_path,
+          :line_number, :backtrace, :fix_suggestion, :code_context,
+          :stderr_warnings
+
+        def initialize(attributes = {})
+          @type = attributes[:type] || :failure  # :failure or :error
+          @test_name = attributes[:test_name]
+          @test_class = attributes[:test_class]
+          @message = attributes[:message]
+          @file_path = attributes[:file_path]
+          @line_number = attributes[:line_number]
+          @backtrace = attributes[:backtrace] || []
+          @fix_suggestion = attributes[:fix_suggestion]
+          @code_context = attributes[:code_context]
+          @stderr_warnings = attributes[:stderr_warnings]
+        end
+
+        def location
+          return nil unless file_path
+
+          if line_number
+            "#{file_path}:#{line_number}"
+          else
+            file_path
+          end
+        end
+
+        def short_location
+          return nil unless file_path
+
+          base_name = File.basename(file_path)
+          line_number ? "#{base_name}:#{line_number}" : base_name
+        end
+
+        def full_test_name
+          test_class ? "#{test_class}##{test_name}" : test_name.to_s
+        end
+
+        def error?
+          type == :error
+        end
+
+        def failure?
+          type == :failure
+        end
+
+        def summary_line
+          "#{type_icon} #{full_test_name} - #{short_location}"
+        end
+
+        def detailed_description
+          lines = []
+          lines << "#{type_icon} #{type.to_s.capitalize}: #{full_test_name}"
+          lines << "  Location: #{location}" if location
+          lines << "  Message: #{message}" if message
+          lines << "  Fix: #{fix_suggestion}" if fix_suggestion
+          lines.join("\n")
+        end
+
+        def to_h
+          {
+            type: type,
+            test_name: test_name,
+            test_class: test_class,
+            message: message,
+            location: location,
+            file_path: file_path,
+            line_number: line_number,
+            backtrace: backtrace,
+            fix_suggestion: fix_suggestion,
+            code_context: code_context,
+            stderr_warnings: stderr_warnings
+          }
+        end
+
+        def to_json(*args)
+          to_h.to_json(*args)
+        end
+
+        private
+
+        def type_icon
+          error? ? "💥" : "❌"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Models
+      # Represents a group of tests to be executed together
+      class TestGroup
+        attr_reader :name, :patterns, :files, :options
+
+        def initialize(name:, patterns: [], files: [], options: {})
+          @name = name
+          @patterns = Array(patterns)
+          @files = Array(files)
+          @options = options
+        end
+
+        # Find all test files matching this group's patterns
+        def find_files
+          return @files unless @files.empty?
+
+          detector = Atoms::TestDetector.new(patterns: @patterns)
+          detector.find_test_files
+        end
+
+        # Execute this group's tests
+        def execute(executor, formatter_options = {})
+          test_files = find_files
+          return empty_result if test_files.empty?
+
+          options = @options.merge(formatter_options)
+          executor.execute_tests(test_files, options)
+        end
+
+        # Check if a file belongs to this group
+        def includes_file?(file_path)
+          return true if @files.include?(file_path)
+
+          @patterns.any? do |pattern|
+            File.fnmatch(pattern, file_path, File::FNM_PATHNAME)
+          end
+        end
+
+        def to_h
+          {
+            name: @name,
+            patterns: @patterns,
+            files: @files,
+            options: @options
+          }
+        end
+
+        # Load groups from configuration
+        def self.from_config(config)
+          groups = config.fetch("groups", default_groups)
+
+          groups.map do |name, definition|
+            new(
+              name: name,
+              patterns: definition["patterns"] || [],
+              files: definition["files"] || [],
+              options: definition.fetch("options", {}).transform_keys(&:to_sym)
+            )
+          end
+        end
+
+        # Default test groups for common Ruby project structures
+        def self.default_groups
+          {
+            "unit" => {
+              "patterns" => ["test/unit/**/*_test.rb", "test/*_test.rb"],
+              "options" => {}
+            },
+            "integration" => {
+              "patterns" => ["test/integration/**/*_test.rb"],
+              "options" => {}
+            },
+            "system" => {
+              "patterns" => ["test/system/**/*_test.rb"],
+              "options" => {"timeout" => 60}
+            },
+            "all" => {
+              "patterns" => ["test/**/*_test.rb"],
+              "options" => {}
+            }
+          }
+        end
+
+        private
+
+        def empty_result
+          {
+            stdout: "",
+            stderr: "No test files found for group '#{@name}'",
+            status: OpenStruct.new(success?: true, exitstatus: 0),
+            command: "",
+            start_time: Time.now,
+            end_time: Time.now,
+            duration: 0.0,
+            success: true
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Ace
+  module TestRunner
+    module Models
+      # Represents a complete test report
+      class TestReport
+        attr_accessor :result, :configuration, :timestamp, :report_path,
+          :files_tested, :environment, :metadata
+
+        def initialize(attributes = {})
+          @result = attributes[:result] || TestResult.new
+          @configuration = attributes[:configuration] || TestConfiguration.new
+          @timestamp = attributes[:timestamp] || Time.now
+          @report_path = attributes[:report_path]
+          @files_tested = attributes[:files_tested] || []
+          @environment = attributes[:environment] || capture_environment
+          @metadata = attributes[:metadata] || {}
+        end
+
+        def success?
+          result.success?
+        end
+
+        def summary
+          {
+            status: success? ? "success" : "failure",
+            passed: result.passed,
+            failed: result.failed,
+            errors: result.errors,
+            skipped: result.skipped,
+            total: result.total_tests,
+            pass_rate: result.pass_rate,
+            duration: result.duration,
+            timestamp: timestamp.iso8601
+          }
+        end
+
+        def failure_summary
+          return [] unless result.has_failures?
+
+          result.failures_detail.map do |failure|
+            {
+              type: failure.type,
+              test: failure.full_test_name,
+              location: failure.location,
+              message: failure.message
+            }
+          end
+        end
+
+        def to_h
+          {
+            summary: summary,
+            result: result.to_h,
+            configuration: configuration.to_h,
+            timestamp: timestamp.iso8601,
+            report_path: report_path,
+            files_tested: files_tested,
+            environment: environment,
+            failures: failure_summary,
+            deprecations: result.deprecations,
+            metadata: metadata
+          }
+        end
+
+        def to_json(*args)
+          to_h.to_json(*args)
+        end
+
+        def to_markdown
+          lines = []
+          lines << "# Test Report"
+          lines << ""
+          lines << "**Generated:** #{timestamp.strftime("%Y-%m-%d %H:%M:%S")}"
+          lines << "**Status:** #{success? ? "✅ Success" : "❌ Failed"}"
+          lines << ""
+
+          lines << "## Summary"
+          lines << ""
+          lines << "| Metric | Value |"
+          lines << "|--------|-------|"
+          lines << "| Total Tests | #{result.total_tests} |"
+          lines << "| Passed | #{result.passed} |"
+          lines << "| Failed | #{result.failed} |"
+          lines << "| Errors | #{result.errors} |"
+          lines << "| Skipped | #{result.skipped} |"
+          lines << "| Pass Rate | #{result.pass_rate}% |"
+          lines << "| Duration | #{result.duration}s |"
+          lines << ""
+
+          if result.has_failures?
+            lines << "## Failures"
+            lines << ""
+            result.failures_detail.each_with_index do |failure, idx|
+              lines << "### #{idx + 1}. #{failure.full_test_name}"
+              lines << ""
+              lines << "- **Type:** #{failure.type}"
+              lines << "- **Location:** `#{failure.location}`"
+              lines << "- **Message:** #{failure.message}"
+              lines << "- **Fix:** #{failure.fix_suggestion}" if failure.fix_suggestion
+              lines << ""
+            end
+          end
+
+          if result.has_deprecations?
+            lines << "## Deprecations"
+            lines << ""
+            result.deprecations.each do |deprecation|
+              lines << "- #{deprecation}"
+            end
+            lines << ""
+          end
+
+          if files_tested.any?
+            lines << "## Files Tested"
+            lines << ""
+            files_tested.each do |file|
+              lines << "- #{file}"
+            end
+            lines << ""
+          end
+
+          lines.join("\n")
+        end
+
+        private
+
+        def capture_environment
+          {
+            ruby_version: RUBY_VERSION,
+            ruby_platform: RUBY_PLATFORM,
+            minitest_version: defined?(Minitest::VERSION) ? Minitest::VERSION : "unknown",
+            ace_test_runner_version: VERSION,
+            working_directory: Dir.pwd,
+            user: ENV["USER"],
+            hostname: ENV["HOSTNAME"] || Socket.gethostname
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Models
+      # Represents the result of a test run
+      class TestResult
+        attr_accessor :passed, :failed, :skipped, :errors, :assertions,
+          :duration, :start_time, :end_time, :failures_detail,
+          :deprecations, :raw_output, :stderr
+
+        def initialize(attributes = {})
+          @passed = attributes[:passed] || 0
+          @failed = attributes[:failed] || 0
+          @skipped = attributes[:skipped] || 0
+          @errors = attributes[:errors] || 0
+          @assertions = attributes[:assertions] || 0
+          @duration = attributes[:duration] || 0.0
+          @start_time = attributes[:start_time]
+          @end_time = attributes[:end_time]
+          @failures_detail = attributes[:failures_detail] || []
+          @deprecations = attributes[:deprecations] || []
+          @raw_output = attributes[:raw_output] || ""
+          @stderr = attributes[:stderr] || ""
+        end
+
+        def total_tests
+          passed + failed + skipped + errors
+        end
+
+        def success?
+          failed == 0 && errors == 0
+        end
+
+        def has_failures?
+          failed > 0 || errors > 0
+        end
+
+        def has_skips?
+          skipped > 0
+        end
+
+        def has_deprecations?
+          deprecations.any?
+        end
+
+        def pass_rate
+          return 0.0 if total_tests == 0
+          (passed.to_f / total_tests * 100).round(2)
+        end
+
+        def summary_line
+          parts = []
+          parts << "✅ #{passed} passed" if passed > 0
+          parts << "❌ #{failed} failed" if failed > 0
+          parts << "💥 #{errors} errors" if errors > 0
+          parts << "⚠️ #{skipped} skipped" if skipped > 0
+
+          parts.empty? ? "No tests executed" : parts.join(", ")
+        end
+
+        def to_h
+          {
+            passed: passed,
+            failed: failed,
+            skipped: skipped,
+            errors: errors,
+            assertions: assertions,
+            total_tests: total_tests,
+            duration: duration,
+            pass_rate: pass_rate,
+            success: success?,
+            start_time: start_time&.iso8601,
+            end_time: end_time&.iso8601,
+            failures: failures_detail.map(&:to_h),
+            deprecations: deprecations
+          }
+        end
+
+        def to_json(*args)
+          to_h.to_json(*args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require_relative "package_resolver"
+
+module Ace
+  module TestRunner
+    module Molecules
+      # Parses CLI arguments to identify package, target, and test files.
+      # Handles the complexity of distinguishing between:
+      # - Direct file paths (./path/file.rb, ../path/file.rb, /abs/path/file.rb)
+      # - Package-prefixed file paths (ace-bundle/test/file.rb)
+      # - Package names (ace-bundle)
+      # - Test targets (atoms, molecules, unit, etc.)
+      class CliArgumentParser
+        KNOWN_TARGETS = %w[atoms molecules organisms models unit integration system all quick].freeze
+
+        attr_reader :package_dir, :target, :test_files
+
+        # @param argv [Array<String>] Command line arguments (will be modified)
+        # @param package_resolver [PackageResolver] Optional resolver for testing
+        def initialize(argv, package_resolver: nil)
+          @argv = argv
+          @package_resolver = package_resolver || PackageResolver.new
+          @package_dir = nil
+          @target = nil
+          @test_files = []
+        end
+
+        # Parse arguments and populate package_dir, target, test_files.
+        #
+        # Parsing precedence (order matters for correct classification):
+        # 1. Existing files (./path/file.rb, ../path/file.rb) - direct file paths
+        # 2. Package-prefixed file paths (ace-bundle/test/file.rb) - sets package + adds file
+        # 3. Package names (ace-bundle) - sets package directory
+        # 4. Known targets (atoms, molecules, etc.) - sets test target
+        # 5. Relative file paths within package (test/file.rb when package is set)
+        # 6. Unrecognized args - treated as custom targets for PatternResolver
+        #
+        # @return [Hash] Parsed options with :package_dir, :target, :files keys
+        def parse
+          parse_first_argument
+          parse_remaining_arguments
+
+          result = {}
+          result[:package_dir] = @package_dir if @package_dir
+          result[:target] = @target if @target
+          result[:files] = @test_files unless @test_files.empty?
+          result
+        end
+
+        # Check if an argument is a known test target
+        # @param arg [String] The argument to check
+        # @return [Boolean]
+        def known_target?(arg)
+          KNOWN_TARGETS.include?(arg)
+        end
+
+        private
+
+        # Extract file path and optional line number from a path string.
+        # Handles both "file.rb" and "file.rb:42" formats.
+        # @param path [String] File path, optionally with :line suffix
+        # @return [Array(String, String|nil)] [file_path, line_number]
+        def extract_file_and_line(path)
+          if path =~ /^(.+\.rb):(\d+)$/
+            [$1, $2]
+          else
+            [path, nil]
+          end
+        end
+
+        # Split a package-prefixed path into package name and file path.
+        # Example: "ace-bundle/test/file.rb" -> ["ace-bundle", "test/file.rb"]
+        # @param arg [String] Package-prefixed path
+        # @return [Array(String, String)] [package_name, file_path]
+        def split_package_prefix(arg)
+          arg.split("/", 2)
+        end
+
+        # Format a file path with optional line number.
+        # @param file_path [String] The file path
+        # @param line_number [String, nil] Optional line number
+        # @return [String] Formatted path (e.g., "file.rb" or "file.rb:42")
+        def format_file_with_line(file_path, line_number)
+          line_number ? "#{file_path}:#{line_number}" : file_path
+        end
+
+        def parse_first_argument
+          first_arg_index = @argv.find_index { |arg| !arg.start_with?("-") }
+          return unless first_arg_index
+
+          first_arg = @argv[first_arg_index]
+
+          # First, check if the argument is an existing file (handles ./path/file.rb, ../path/file.rb)
+          # This must be checked BEFORE package detection to avoid misclassification
+          if existing_file?(first_arg)
+            @test_files << first_arg
+            @argv.delete_at(first_arg_index)
+            return
+          end
+
+          # Check for package-prefixed file path (e.g., ace-bundle/test/foo_test.rb)
+          if package_prefixed_file_path?(first_arg)
+            handle_package_prefixed_path(first_arg, first_arg_index)
+            return
+          end
+
+          # Check if first arg is a package (not a known target, not a ruby file, not file:line)
+          return if @package_dir || !@test_files.empty?
+
+          handle_potential_package(first_arg, first_arg_index)
+        end
+
+        def parse_remaining_arguments
+          @argv.each do |arg|
+            next if arg.start_with?("-")
+
+            # Check package-prefixed paths first (before file_with_line?) to handle
+            # cases like "ace-bundle/test/file.rb:42" correctly when package is resolved
+            if @package_dir && handle_remaining_package_prefixed_path(arg)
+              next
+            elsif file_with_line?(arg)
+              handle_file_with_line(arg)
+            elsif existing_ruby_file?(arg)
+              @test_files << arg
+            elsif package_relative_ruby_file?(arg)
+              @test_files << arg
+            elsif known_target?(arg)
+              @target = arg
+            elsif @target.nil? && !File.exist?(arg)
+              # Unrecognized target - will be handled by PatternResolver
+              @target = arg
+            end
+          end
+        end
+
+        def existing_file?(arg)
+          file_arg = arg.sub(/:\d+$/, "") # Strip line number if present
+          File.file?(file_arg) && file_arg.end_with?(".rb")
+        end
+
+        def package_prefixed_file_path?(arg)
+          arg.include?("/") && (arg.end_with?(".rb") || arg =~ /\.rb:\d+$/)
+        end
+
+        # Handle package-prefixed file paths in remaining args when package already resolved.
+        # Example: "ace-bundle ace-bundle/test/foo.rb" - second arg should be recognized
+        # as a file within the already-resolved package.
+        # @return [Boolean] true if arg was handled as a package-prefixed file
+        def handle_remaining_package_prefixed_path(arg)
+          return false unless package_prefixed_file_path?(arg)
+
+          potential_package, file_path = split_package_prefix(arg)
+
+          # Check if the prefix matches our resolved package
+          resolved_package = @package_resolver.resolve(potential_package)
+          return false unless resolved_package == @package_dir
+
+          file_path_only, line_number = extract_file_and_line(file_path)
+
+          full_file_path = File.join(@package_dir, file_path_only)
+          return false unless File.exist?(full_file_path)
+
+          @test_files << format_file_with_line(file_path_only, line_number)
+          true
+        end
+
+        def handle_package_prefixed_path(arg, index)
+          # Split into package name and file path using first "/" as delimiter.
+          # This assumes package names don't contain "/" (true for all ace-* packages).
+          # Note: If a package were ever named with "/" (e.g., "ace/context"), this
+          # would misparse it. Current ace-* naming convention prevents this issue.
+          potential_package, file_path = split_package_prefix(arg)
+          file_path_only, line_number = extract_file_and_line(file_path)
+
+          # Try to resolve the package
+          resolved_package = @package_resolver.resolve(potential_package)
+          return unless resolved_package
+
+          full_file_path = File.join(resolved_package, file_path_only)
+          return unless File.exist?(full_file_path)
+
+          @package_dir = resolved_package
+          @test_files << format_file_with_line(file_path_only, line_number)
+          @argv.delete_at(index)
+        end
+
+        def handle_potential_package(arg, index)
+          return unless potential_package?(arg)
+
+          # Try to resolve as package (works for package names and explicit paths)
+          resolved_path = @package_resolver.resolve(arg)
+          if resolved_path
+            @package_dir = resolved_path
+            @argv.delete_at(index)
+          elsif explicit_path?(arg)
+            raise_package_not_found_error(arg)
+          elsif looks_like_package_name?(arg)
+            # Package-like name (e.g., ace-foo) that didn't resolve - give helpful error
+            raise_package_not_found_error(arg)
+          end
+          # Otherwise, fall through and let it be handled as target/file
+        end
+
+        # Check if argument looks like a package name (ace-* pattern)
+        def looks_like_package_name?(arg)
+          arg.start_with?("ace-") && !arg.include?("/")
+        end
+
+        # Check if an argument could be a package name (not a target, file, or file:line)
+        def potential_package?(arg)
+          !known_target?(arg) &&
+            !(arg.end_with?(".rb") && File.file?(arg)) &&
+            !file_with_line?(arg)
+        end
+
+        def explicit_path?(arg)
+          arg.start_with?("./", "../", "/")
+        end
+
+        def file_with_line?(arg)
+          arg =~ /^(.+):(\d+)$/
+        end
+
+        def handle_file_with_line(arg)
+          file_part, line_part = extract_file_and_line(arg)
+
+          # If we have a package_dir, make the path relative to it
+          check_path = @package_dir ? File.join(@package_dir, file_part) : file_part
+
+          unless File.exist?(check_path)
+            raise ArgumentError, "File not found: #{check_path}"
+          end
+
+          # Store the path that will work from the package directory
+          @test_files << (@package_dir ? format_file_with_line(file_part, line_part) : arg)
+        end
+
+        def existing_ruby_file?(arg)
+          File.exist?(arg) && arg.end_with?(".rb")
+        end
+
+        def package_relative_ruby_file?(arg)
+          @package_dir && File.exist?(File.join(@package_dir, arg)) && arg.end_with?(".rb")
+        end
+
+        def raise_package_not_found_error(arg)
+          message = "Package not found: #{arg}\n"
+          message += if Dir.exist?(arg)
+            "Directory exists but has no test/ subdirectory.\n"
+          else
+            "Directory does not exist.\n"
+          end
+
+          available = @package_resolver.available_packages
+          message += "Available packages: #{available.join(", ")}" if available.any?
+
+          raise ArgumentError, message
+        end
+      end
+    end
+  end
+end