ace-test-runner 0.19.1 → 0.25.7

data/lib/ace/test_runner/models/{test_group.rb → test_target.rb}

@@ -3,8 +3,8 @@
 module Ace
   module TestRunner
     module Models
-      # Represents a group of tests to be executed together
-      class TestGroup
+      # Represents a target of tests to be executed together
+      class TestTarget
         attr_reader :name, :patterns, :files, :options
 
         def initialize(name:, patterns: [], files: [], options: {})
@@ -14,7 +14,7 @@ module Ace
           @options = options
         end
 
-        # Find all test files matching this group's patterns
+        # Find all test files matching this target's patterns
         def find_files
           return @files unless @files.empty?
 
@@ -22,7 +22,7 @@ module Ace
           detector.find_test_files
         end
 
-        # Execute this group's tests
+        # Execute this target's tests
         def execute(executor, formatter_options = {})
           test_files = find_files
           return empty_result if test_files.empty?
@@ -31,7 +31,7 @@ module Ace
           executor.execute_tests(test_files, options)
         end
 
-        # Check if a file belongs to this group
+        # Check if a file belongs to this target
         def includes_file?(file_path)
           return true if @files.include?(file_path)
 
@@ -49,11 +49,11 @@ module Ace
           }
         end
 
-        # Load groups from configuration
+        # Load targets from configuration
         def self.from_config(config)
-          groups = config.fetch("groups", default_groups)
+          targets = config.fetch("targets", default_targets)
 
-          groups.map do |name, definition|
+          targets.map do |name, definition|
             new(
               name: name,
               patterns: definition["patterns"] || [],
@@ -63,23 +63,19 @@ module Ace
           end
         end
 
-        # Default test groups for common Ruby project structures
-        def self.default_groups
+        # Default test targets for common Ruby project structures
+        def self.default_targets
           {
-            "unit" => {
-              "patterns" => ["test/unit/**/*_test.rb", "test/*_test.rb"],
+            "fast" => {
+              "patterns" => ["test/fast/**/*_test.rb", "test/*_test.rb", "test/unit/**/*_test.rb"],
               "options" => {}
             },
-            "integration" => {
-              "patterns" => ["test/integration/**/*_test.rb"],
+            "feat" => {
+              "patterns" => ["test/feat/**/*_test.rb", "test/edge/**/*_test.rb"],
               "options" => {}
             },
-            "system" => {
-              "patterns" => ["test/system/**/*_test.rb"],
-              "options" => {"timeout" => 60}
-            },
             "all" => {
-              "patterns" => ["test/**/*_test.rb"],
+              "patterns" => ["test/fast/**/*_test.rb", "test/*_test.rb", "test/feat/**/*_test.rb", "test/edge/**/*_test.rb"],
               "options" => {}
             }
           }
@@ -90,7 +86,7 @@ module Ace
         def empty_result
           {
             stdout: "",
-            stderr: "No test files found for group '#{@name}'",
+            stderr: "No test files found for target '#{@name}'",
             status: OpenStruct.new(success?: true, exitstatus: 0),
             command: "",
             start_time: Time.now,

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

@@ -10,9 +10,9 @@ module Ace
       # - 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.)
+      # - Test targets (atoms, molecules, fast, feat, etc.)
       class CliArgumentParser
-        KNOWN_TARGETS = %w[atoms molecules organisms models unit integration system all quick].freeze
+        KNOWN_TARGETS = %w[atoms molecules organisms models fast feat all quick].freeze
 
         attr_reader :package_dir, :target, :test_files
 

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

@@ -145,7 +145,7 @@ module Ace
         def normalize_config(config)
           # Ensure all sections exist as hashes (defaults already merged in load)
           config[:patterns] ||= {}
-          config[:groups] ||= {}
+          config[:targets] ||= {}
           config[:defaults] ||= {}
           config[:failure_limits] ||= {}
           config[:execution] ||= {}

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

@@ -4,24 +4,30 @@ module Ace
   module TestRunner
     module Molecules
       class PatternResolver
+        INTERNAL_PATTERN_LABELS = {
+          "feat_tests" => "feat"
+        }.freeze
+
         attr_reader :using_catch_all
 
         def initialize(config)
           @config = config
           @patterns = normalize_keys(config.patterns || {})
-          @groups = normalize_keys(config.groups || {})
+          @targets = normalize_keys(config.targets || {})
           @using_catch_all = false
         end
 
         def resolve_target(target)
-          return resolve_all_files if target.nil? || target == "all"
+          return resolve_named_target("fast") if target.nil?
+          return resolve_all_files if target == "all"
           return [target] if File.exist?(target)
 
           # Normalize target to string for consistent lookup
           target_key = target.to_s
+          raise_unsupported_target_error(target_key) if %w[e2e all-with-e2e system].include?(target_key)
 
-          if @groups.key?(target_key)
-            resolve_group(target_key)
+          if @targets.key?(target_key)
+            resolve_named_target(target_key)
           elsif @patterns.key?(target_key)
             expand_pattern(@patterns[target_key])
           elsif looks_like_file_path?(target)
@@ -36,23 +42,24 @@ module Ace
           targets.flat_map { |target| resolve_target(target) }.uniq
         end
 
-        def resolve_group_sequential(group_name)
-          group_key = group_name.to_s
-          group_members = @groups[group_key]
-          return [] unless group_members
+        def resolve_target_sequential(target_name, seen = [])
+          target_key = target_name.to_s
+          if seen.include?(target_key)
+            raise ArgumentError, "Cyclic test target definition detected: #{(seen + [target_key]).join(' -> ')}"
+          end
+
+          target_members = @targets[target_key]
+          return [] unless target_members
 
-          group_members.flat_map do |member|
+          target_members.flat_map do |member|
             member_key = member.to_s
 
-            if @groups.key?(member_key)
-              # Recursively expand nested groups
-              resolve_group_sequential(member_key)
+            if @targets.key?(member_key)
+              resolve_target_sequential(member_key, seen + [target_key])
             elsif @patterns.key?(member_key)
-              # Pattern found - return as a group
               files = expand_pattern(@patterns[member_key])
-              files.empty? ? [] : [{name: member_key, files: files}]
+              files.empty? ? [] : [{name: display_name_for(member_key), files: files}]
             else
-              # Direct pattern - expand and wrap
               files = expand_pattern(member)
               files.empty? ? [] : [{name: "other", files: files}]
             end
@@ -60,19 +67,35 @@ module Ace
         end
 
         def available_targets
-          (@groups.keys + @patterns.keys).map(&:to_s).sort
+          (@targets.keys + @patterns.keys)
+            .map(&:to_s)
+            .reject { |name| INTERNAL_PATTERN_LABELS.key?(name) }
+            .sort
         end
 
         def classify_file(file_path)
           @patterns.each do |name, pattern|
-            # Use File::FNM_PATHNAME to handle ** correctly
-            return name.to_s if File.fnmatch?(pattern, file_path, File::FNM_PATHNAME)
+            if File.fnmatch?(pattern, file_path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+              return display_name_for(name)
+            end
           end
           "other"
         end
 
         private
 
+        def display_name_for(name)
+          INTERNAL_PATTERN_LABELS.fetch(name.to_s, name.to_s)
+        end
+
+        def raise_unsupported_target_error(target)
+          if target == "e2e"
+            raise ArgumentError, "Unsupported target: e2e. Use `ace-test-e2e <package>`."
+          end
+
+          raise ArgumentError, "Unsupported target: #{target}"
+        end
+
         def looks_like_file_path?(target)
           target.include?("/") || target.end_with?(".rb")
         end
@@ -81,21 +104,23 @@ module Ace
           hash.transform_keys(&:to_s)
         end
 
-        def resolve_group(group_name)
-          # Normalize to string
-          group_key = group_name.to_s
-          group_members = @groups[group_key]
-          return [] unless group_members
+        def resolve_named_target(target_name, seen = [])
+          target_key = target_name.to_s
+          if seen.include?(target_key)
+            raise ArgumentError, "Cyclic test target definition detected: #{(seen + [target_key]).join(' -> ')}"
+          end
+
+          target_members = @targets[target_key]
+          return [] unless target_members
 
-          group_members.flat_map do |member|
+          target_members.flat_map do |member|
             member_key = member.to_s
 
-            if @groups.key?(member_key)
-              resolve_group(member_key) # Recursive expansion
+            if @targets.key?(member_key)
+              resolve_named_target(member_key, seen + [target_key])
             elsif @patterns.key?(member_key)
               expand_pattern(@patterns[member_key])
             else
-              # Direct pattern or file
               expand_pattern(member)
             end
           end.uniq
@@ -106,19 +131,15 @@ module Ace
         end
 
         def resolve_all_files
-          # Always start by finding ALL test files that exist
+          # Catch-all default selection should not silently widen back into
+          # deterministic E2E tests when the configured "all" target excludes them.
           all_test_files = expand_pattern("test/**/*_test.rb")
+          catch_all_files = all_test_files - expand_pattern("test/e2e/**/*_test.rb")
           @using_catch_all = false
 
-          # First check if "all" group is defined
-          if @groups.key?("all")
-            pattern_files = resolve_group("all")
-            # If patterns miss any files, use the complete scan
-            if pattern_files.size < all_test_files.size
-              @using_catch_all = true
-              return all_test_files
-            end
-            return pattern_files
+          # First check if "all" target is defined
+          if @targets.key?("all")
+            return resolve_named_target("all")
           end
 
           # If no "all" group, try all defined patterns
@@ -131,14 +152,14 @@ module Ace
             # If patterns miss any files, use the complete scan
             if pattern_files.size < all_test_files.size
               @using_catch_all = true
-              return all_test_files
+              return catch_all_files
             end
             return pattern_files
           end
 
           # No configuration - using catch-all pattern
           @using_catch_all = true
-          all_test_files
+          catch_all_files
         end
       end
     end

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

@@ -65,9 +65,9 @@ module Ace
           return :subprocess if options[:subprocess] || @force_mode == :subprocess
           return :direct if options[:direct] || @force_mode == :direct
 
-          # Check group_isolation config for sequential group execution
+          # Check target_isolation config for sequential target execution
           # true = subprocess for better isolation
-          if options[:group_isolation] == true
+          if options[:target_isolation] == true
             return :subprocess
           end
 

data/lib/ace/test_runner/organisms/{sequential_group_executor.rb → sequential_target_executor.rb}

@@ -3,28 +3,28 @@
 module Ace
   module TestRunner
     module Organisms
-      # Executes test groups sequentially with visual separation and fail-fast support
-      class SequentialGroupExecutor
+      # Executes test targets sequentially with visual separation and fail-fast support
+      class SequentialTargetExecutor
         def initialize(test_executor:, result_parser:, formatter: nil)
           @test_executor = test_executor
           @result_parser = result_parser
           @formatter = formatter
         end
 
-        def execute_groups(groups, options = {})
-          fail_fast = options[:fail_fast] || options[:group_fail_fast]
+        def execute_targets(targets, options = {})
+          fail_fast = options[:fail_fast] || options[:target_fail_fast]
           all_results = []
           all_files = []
-          group_results = []
+          target_results = []
 
-          groups.each do |group|
-            group_name = group[:name]
-            files = group[:files]
+          targets.each do |target|
+            target_name = target[:name]
+            files = target[:files]
             next if files.empty?
 
-            # Notify formatter of group start
-            if @formatter&.respond_to?(:on_group_start)
-              @formatter.on_group_start(group_name, files.size)
+            # Notify formatter of target start
+            if @formatter&.respond_to?(:on_target_start)
+              @formatter.on_target_start(target_name, files.size)
             end
 
             start_time = Time.now
@@ -45,20 +45,20 @@ module Ace
             duration = Time.now - start_time
             success = result[:success]
 
-            # Store group result
-            group_result = {
-              name: group_name,
+            # Store target result
+            target_result = {
+              name: target_name,
               success: success,
               duration: duration,
               parsed: parsed,
               files: files
             }
-            group_results << group_result
+            target_results << target_result
 
-            # Notify formatter of group completion
-            if @formatter&.respond_to?(:on_group_complete)
-              @formatter.on_group_complete(
-                group_name,
+            # Notify formatter of target completion
+            if @formatter&.respond_to?(:on_target_complete)
+              @formatter.on_target_complete(
+                target_name,
                 success,
                 duration,
                 parsed[:summary]
@@ -69,15 +69,14 @@ module Ace
             all_results << result
             all_files.concat(files)
 
-            # Stop if group failed and fail_fast is enabled
+            # Stop if target failed and fail_fast is enabled
             if fail_fast && !success
-              # Return early with aggregated results so far
-              return build_aggregated_result(group_results, all_files, all_results, stopped: group_name)
+              return build_aggregated_result(target_results, all_files, all_results, stopped: target_name)
             end
           end
 
-          # All groups completed successfully (or fail_fast not enabled)
-          build_aggregated_result(group_results, all_files, all_results)
+          # All targets completed successfully (or fail_fast not enabled)
+          build_aggregated_result(target_results, all_files, all_results)
         end
 
         private
@@ -123,7 +122,7 @@ module Ace
           aggregated
         end
 
-        def build_aggregated_result(group_results, all_files, all_results, stopped: nil)
+        def build_aggregated_result(target_results, all_files, all_results, stopped: nil)
           # Aggregate all parsed results
           total_summary = {
             runs: 0,
@@ -138,8 +137,8 @@ module Ace
           total_duration = 0.0
           all_test_times = []
 
-          group_results.each do |gr|
-            parsed = gr[:parsed]
+          target_results.each do |tr|
+            parsed = tr[:parsed]
             total_summary[:runs] += parsed[:summary][:runs]
             total_summary[:assertions] += parsed[:summary][:assertions]
             total_summary[:failures] += parsed[:summary][:failures]
@@ -149,7 +148,7 @@ module Ace
 
             all_failures.concat(parsed[:failures] || [])
             all_deprecations.concat(parsed[:deprecations] || [])
-            total_duration += gr[:duration]
+            total_duration += tr[:duration]
             all_test_times.concat(parsed[:test_times] || [])
           end
 
@@ -176,7 +175,7 @@ module Ace
               duration: total_duration,
               test_times: all_test_times
             },
-            stopped_at_group: stopped
+            stopped_at_target: stopped
           }
         end
       end

data/lib/ace/test_runner/organisms/test_orchestrator.rb

@@ -4,7 +4,7 @@ require_relative "../formatters/base_formatter"
 require_relative "../molecules/config_loader"
 require_relative "../molecules/pattern_resolver"
 require_relative "../atoms/report_directory_resolver"
-require_relative "sequential_group_executor"
+require_relative "sequential_target_executor"
 
 module Ace
   module TestRunner
@@ -63,11 +63,11 @@ module Ace
             puts "Running tests in #{File.basename(@package_dir)}..."
           end
 
-          # Check if sequential group execution should be used
+          # Check if sequential target execution should be used
           if should_execute_sequentially?
-            # Use default "all" group if no target specified in grouped mode
-            @configuration.target ||= "all"
-            return run_sequential_groups(start_time)
+            # Use default "fast" target if no target specified in by-target mode
+            @configuration.target ||= "fast"
+            return run_sequential_targets(start_time)
           end
 
           # Find test files
@@ -116,7 +116,7 @@ module Ace
             # Each file was executed separately, parse and sum them all
             aggregate_individual_results(execution_result[:stdout])
           else
-            # Single command execution (grouped)
+            # Single command execution (by-target)
             @result_parser.parse_output(execution_result[:stdout])
           end
 
@@ -199,21 +199,19 @@ module Ace
           if @configuration.failure_limits
             formatter_options[:max_failures_to_display] = @configuration.failure_limits[:max_display]
           end
-          # Disable group headers in on_test_complete to avoid duplicates with on_group_start/complete
+          # Disable target headers in on_test_complete to avoid duplicates with on_target_start/complete
           formatter_options[:show_groups] = false
           @formatter = @configuration.formatter_class.new(formatter_options)
         end
 
-        def run_sequential_groups(start_time)
-          # Resolve groups sequentially
-          groups = @pattern_resolver.resolve_group_sequential(@configuration.target)
+        def run_sequential_targets(start_time)
+          targets = @pattern_resolver.resolve_target_sequential(@configuration.target)
 
-          if groups.empty?
+          if targets.empty?
             return handle_no_tests
           end
 
-          # Count total files
-          all_files = groups.flat_map { |g| g[:files] }
+          all_files = targets.flat_map { |t| t[:files] }
 
           resolve_and_set_report_dir_context(all_files)
 
@@ -226,15 +224,13 @@ module Ace
             @formatter.on_start(all_files.size)
           end
 
-          # Create sequential executor
-          executor = SequentialGroupExecutor.new(
+          executor = SequentialTargetExecutor.new(
             test_executor: @test_executor,
             result_parser: @result_parser,
             formatter: @formatter
           )
 
-          # Execute groups sequentially
-          execution_result = executor.execute_groups(groups, sequential_options) do |event|
+          execution_result = executor.execute_targets(targets, sequential_options) do |event|
             case event[:type]
             when :stdout
               @formatter.on_test_stdout(event[:content]) if @formatter.respond_to?(:on_test_stdout)
@@ -297,8 +293,8 @@ module Ace
           end
 
           # Show stopped message if execution was stopped
-          if execution_result[:stopped_at_group]
-            puts "\nSTOPPED: Group '#{execution_result[:stopped_at_group]}' failed (--fail-fast enabled)"
+          if execution_result[:stopped_at_target]
+            puts "\nSTOPPED: Target '#{execution_result[:stopped_at_target]}' failed (--fail-fast enabled)"
           end
 
           # Return exit code
@@ -310,10 +306,9 @@ module Ace
           # This ensures that commands like `ace-test test/atoms/foo_test.rb` run only that file
           return false if @configuration.files && !@configuration.files.empty?
 
-          # Only use sequential groups if execution_mode is "grouped"
-          return false unless @configuration.execution_mode == "grouped"
+          return false unless @configuration.execution_mode == "by-target"
 
-          # Explicit --run-in-single-batch bypasses grouped execution
+          # Explicit --run-in-single-batch bypasses by-target execution
           return false if @configuration.run_in_single_batch
 
           # When profiling without a specific target, run as single batch for accurate timing
@@ -322,14 +317,14 @@ module Ace
             return false
           end
 
-          # If no target specified, default to "all" group for grouped mode
-          target = @configuration.target || "all"
+          # If no target specified, default to "fast" target for by-target mode
+          target = @configuration.target || "fast"
 
           target_str = target.to_s
           target_sym = target.to_sym
 
           # Check both string and symbol keys for compatibility
-          @configuration.groups&.key?(target_str) || @configuration.groups&.key?(target_sym)
+          @configuration.targets&.key?(target_str) || @configuration.targets&.key?(target_sym)
         end
 
         def sequential_options
@@ -338,8 +333,8 @@ module Ace
             verbose: @configuration.verbose,
             per_file: @configuration.per_file,
             profile: @configuration.profile,
-            group_fail_fast: @configuration.execution&.[](:group_fail_fast),
-            group_isolation: @configuration.group_isolation
+            target_fail_fast: @configuration.execution&.[](:target_fail_fast),
+            target_isolation: @configuration.target_isolation
           }
         end
 
@@ -361,7 +356,7 @@ module Ace
             filter: options[:filter],
             fix_deprecations: options[:fix_deprecations],
             patterns: config_with_options.patterns,
-            groups: config_with_options.groups,
+            targets: config_with_options.targets,
             target: options[:target],
             config_path: options[:config_path],
             timeout: options[:timeout],
@@ -413,7 +408,7 @@ module Ace
             exit 1
           end
 
-          # If using catch-all pattern, reinitialize formatter without groups
+          # If using catch-all pattern, reinitialize formatter without target headers
           if @pattern_resolver.using_catch_all
             formatter_options = @configuration.to_h.merge(show_groups: false)
             if @configuration.failure_limits
@@ -454,11 +449,11 @@ module Ace
             verbose: @configuration.verbose,
             per_file: @configuration.per_file,  # Allow per-file execution if needed for debugging
             profile: @configuration.profile,      # Add profile option for verbose timing
-            group_isolation: @configuration.group_isolation  # Pass through for execution mode selection
+            target_isolation: @configuration.target_isolation  # Pass through for execution mode selection
           }
 
           # Always use execute_with_progress for consistent interface
-          # The method internally decides whether to run per-file or grouped
+          # The method internally decides whether to run per-file or by-target
           @test_executor.execute_with_progress(test_files, options) do |event|
             case event[:type]
             when :stdout