chore: failing discovery tests

Author: denis256

internal/discovery/discovery.go

@@ -1251,6 +1251,8 @@ func (d *Discovery) Discover(
 		}
 	}
 
+	allComponents := components
+
 	if len(d.filters) > 0 {
 		filtered, evaluateErr := d.filters.Evaluate(l, components)
 		if evaluateErr != nil {
@@ -1285,12 +1287,10 @@ func (d *Discovery) Discover(
 		return components, errors.Join(errs...)
 	}
 
-	// When filter queries include ONLY dependents (e.g., ...{target}) and NO dependencies,
-	// apply additional pruning to retain only the target(s) and their transitive dependents.
-	// Skip this when dependency expressions exist (e.g., ...{target}...) since those require
-	// keeping both dependencies AND dependents.
-	if len(d.dependencyTargetExpressions) == 0 {
-		components = d.applyDependentTargeting(l, components)
+	// When filter queries include dependents (e.g., ...{target}), re-expand the filtered set
+	// to include the target(s) and their transitive dependents from the full component graph.
+	if len(d.dependentTargetExpressions) > 0 {
+		components = d.applyDependentTargeting(allComponents, components)
 	}
 
 	if d.graphTarget != "" {
@@ -1326,43 +1326,32 @@ func (d *Discovery) filterGraphTarget(components component.Components) (componen
 	return filterByAllowSet(components, allowed), nil
 }
 
-// applyDependentTargeting prunes the discovered components to the union of all
-// filter targets that requested dependents (via ... prefix) and their transitive dependents.
-// This aligns behavior with --graph-target pruning when the filter queries specify dependents.
-func (d *Discovery) applyDependentTargeting(l log.Logger, components component.Components) component.Components {
+// applyDependentTargeting re-expands the filtered set of components to include
+// the target(s) selected by dependent filter expressions and their transitive dependents.
+func (d *Discovery) applyDependentTargeting(full component.Components, filtered component.Components) component.Components {
 	if len(d.dependentTargetExpressions) == 0 {
-		return components
+		return filtered
 	}
 
-	// Build dependents index once over the full component graph.
-	dependentUnits := buildDependentsIndex(components)
+	dependentUnits := buildDependentsIndex(full)
 	propagateTransitiveDependents(dependentUnits)
 
 	allowed := make(map[string]struct{})
 
-	for _, targetExpr := range d.dependentTargetExpressions {
-		matched, err := filter.Evaluate(l, targetExpr, components)
-		if err != nil {
-			l.Warnf("Failed to evaluate dependent target expression %q: %v", targetExpr, err)
-
-			continue
-		}
-
-		for _, c := range matched {
-			targetPath := resolvePath(c.Path())
-			allowed[targetPath] = struct{}{}
+	for _, target := range filtered {
+		targetPath := resolvePath(target.Path())
+		allowed[targetPath] = struct{}{}
 
-			for _, dep := range dependentUnits[targetPath] {
-				allowed[dep] = struct{}{}
-			}
+		for _, dep := range dependentUnits[targetPath] {
+			allowed[dep] = struct{}{}
 		}
 	}
 
 	if len(allowed) == 0 {
-		return components
+		return filtered
 	}
 
-	return filterByAllowSet(components, allowed)
+	return filterByAllowSet(full, allowed)
 }
 
 // canonicalizeGraphTarget resolves the graph target to an absolute, cleaned path with symlinks resolved.

internal/discovery/discovery_test.go

@@ -14,6 +14,14 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+func normPath(p string) string {
+	if resolved, err := filepath.EvalSymlinks(p); err == nil {
+		return resolved
+	}
+
+	return p
+}
+
 func TestDiscovery(t *testing.T) {
 	t.Parallel()
 
@@ -230,7 +238,7 @@ func TestDiscoveryWithDependencies(t *testing.T) {
 
 			for i, c := range components {
 				want := wantDiscovery[i]
-				assert.Equal(t, want.Path(), c.Path(), "Component path mismatch at index %d", i)
+				assert.Equal(t, normPath(want.Path()), normPath(c.Path()), "Component path mismatch at index %d", i)
 				assert.Equal(t, want.Kind(), c.Kind(), "Component kind mismatch at index %d", i)
 				assert.Equal(t, want.External(), c.External(), "Component external flag mismatch at index %d", i)
 
@@ -241,7 +249,7 @@ func TestDiscoveryWithDependencies(t *testing.T) {
 
 				for j, dep := range cfgDeps {
 					wantDep := wantDeps[j]
-					assert.Equal(t, wantDep.Path(), dep.Path(), "Dependency path mismatch at component %d, dependency %d", i, j)
+					assert.Equal(t, normPath(wantDep.Path()), normPath(dep.Path()), "Dependency path mismatch at component %d, dependency %d", i, j)
 					assert.Equal(t, wantDep.Kind(), dep.Kind(), "Dependency kind mismatch at component %d, dependency %d", i, j)
 					assert.Equal(t, wantDep.External(), dep.External(), "Dependency external flag mismatch at component %d, dependency %d", i, j)
 
@@ -252,7 +260,7 @@ func TestDiscoveryWithDependencies(t *testing.T) {
 
 					for k, nestedDep := range depDeps {
 						wantNestedDep := wantDepDeps[k]
-						assert.Equal(t, wantNestedDep.Path(), nestedDep.Path(), "Nested dependency path mismatch")
+						assert.Equal(t, normPath(wantNestedDep.Path()), normPath(nestedDep.Path()), "Nested dependency path mismatch")
 					}
 				}
 			}

test/integration_report_test.go

@@ -542,14 +542,19 @@ func TestReportWithExternalDependenciesExcluded(t *testing.T) {
 	// Verify that the report file contains the expected content
 	assert.Len(t, report, 2)
 
+	depPath := dep
+	if resolved, err := filepath.EvalSymlinks(dep); err == nil {
+		depPath = resolved
+	}
+
 	expected := []struct {
 		name   string
 		result string
 		reason string
 	}{
 		// The first run is always going to be the external dependency,
 		// as it has an instant runtime.
-		{name: dep, result: "excluded", reason: "--queue-exclude-external"},
+		{name: depPath, result: "excluded", reason: "--queue-exclude-external"},
 		{name: "external-dependency", result: "succeeded"},
 	}