fix: backendRefUnknownKind test case

internal/controller/httproute_controller.go

@@ -170,9 +170,14 @@ func (r *HTTPRouteReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 		}
 	}
 
+	var httpRouteErr error
 	if err := r.processHTTPRoute(tctx, hr); err != nil {
-		acceptStatus.status = false
-		acceptStatus.msg = err.Error()
+		httpRouteErr = err
+		// When encountering a backend reference error, it should not affect the acceptance status
+		if !strings.Contains(err.Error(), string(gatewayv1.RouteReasonInvalidKind)) {
+			acceptStatus.status = false
+			acceptStatus.msg = err.Error()
+		}
 	}
 
 	if err := r.processHTTPRoutePolicies(tctx, hr); err != nil {
@@ -187,6 +192,13 @@ func (r *HTTPRouteReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 		}
 	}
 
+	// If the backend reference error is because of an invalid kind, use this error first
+	if httpRouteErr != nil && strings.Contains(httpRouteErr.Error(), string(gatewayv1.RouteReasonInvalidKind)) {
+		resolveRefStatus = status{
+			status: false,
+			msg:    httpRouteErr.Error(),
+		}
+	}
 	ProcessBackendTrafficPolicy(r.Client, r.Log, tctx)
 
 	if err := r.Provider.Update(ctx, tctx, hr); err != nil {
@@ -492,7 +504,7 @@ func (r *HTTPRouteReconciler) processHTTPRoute(tctx *provider.TranslateContext,
 				kind = strings.ToLower(string(*backend.Kind))
 			}
 			if kind != "service" {
-				terror = fmt.Errorf("kind %s is not supported", kind)
+				terror = fmt.Errorf("%s %s", string(gatewayv1.RouteReasonInvalidKind), kind)
 				continue
 			}
 

internal/controller/utils.go

@@ -249,10 +249,16 @@ func SetRouteConditionResolvedRefs(routeParentStatus *gatewayv1.RouteParentStatu
 		conditionStatus = metav1.ConditionFalse
 	}
 
+	reason := string(gatewayv1.RouteReasonResolvedRefs)
+	// check if the error message contains InvalidKind
+	if !status && strings.Contains(message, string(gatewayv1.RouteReasonInvalidKind)) {
+		reason = string(gatewayv1.RouteReasonInvalidKind)
+	}
+
 	condition := metav1.Condition{
 		Type:               string(gatewayv1.RouteConditionResolvedRefs),
 		Status:             conditionStatus,
-		Reason:             string(gatewayv1.RouteReasonResolvedRefs),
+		Reason:             reason,
 		ObservedGeneration: generation,
 		Message:            message,
 		LastTransitionTime: metav1.Now(),

internal/provider/adc/translator/httproute.go

@@ -307,14 +307,18 @@ func (t *Translator) translateEndpointSlice(portName *string, weight int, endpoi
 	return nodes
 }
 
-func (t *Translator) translateBackendRef(tctx *provider.TranslateContext, ref gatewayv1.BackendRef) adctypes.UpstreamNodes {
+func (t *Translator) translateBackendRef(tctx *provider.TranslateContext, ref gatewayv1.BackendRef) (adctypes.UpstreamNodes, error) {
+	if ref.Kind != nil && *ref.Kind != "Service" {
+		return adctypes.UpstreamNodes{}, fmt.Errorf("kind %s is not supported", *ref.Kind)
+	}
+
 	key := types.NamespacedName{
 		Namespace: string(*ref.Namespace),
 		Name:      string(ref.Name),
 	}
 	service, ok := tctx.Services[key]
 	if !ok {
-		return adctypes.UpstreamNodes{}
+		return adctypes.UpstreamNodes{}, fmt.Errorf("service %s not found", key)
 	}
 
 	weight := 1
@@ -333,7 +337,7 @@ func (t *Translator) translateBackendRef(tctx *provider.TranslateContext, ref ga
 				Port:   port,
 				Weight: weight,
 			},
-		}
+		}, nil
 	}
 
 	var portName *string
@@ -345,12 +349,12 @@ func (t *Translator) translateBackendRef(tctx *provider.TranslateContext, ref ga
 			}
 		}
 		if portName == nil {
-			return adctypes.UpstreamNodes{}
+			return adctypes.UpstreamNodes{}, nil
 		}
 	}
 
 	endpointSlices := tctx.EndpointSlices[key]
-	return t.translateEndpointSlice(portName, weight, endpointSlices)
+	return t.translateEndpointSlice(portName, weight, endpointSlices), nil
 }
 
 // calculateHTTPRoutePriority calculates the priority of the HTTP route.
@@ -424,12 +428,17 @@ func (t *Translator) TranslateHTTPRoute(tctx *provider.TranslateContext, httpRou
 
 	for ruleIndex, rule := range rules {
 		upstream := adctypes.NewDefaultUpstream()
+		var backendErr error
 		for _, backend := range rule.BackendRefs {
 			if backend.Namespace == nil {
 				namespace := gatewayv1.Namespace(httpRoute.Namespace)
 				backend.Namespace = &namespace
 			}
-			upNodes := t.translateBackendRef(tctx, backend.BackendRef)
+			upNodes, err := t.translateBackendRef(tctx, backend.BackendRef)
+			if err != nil {
+				backendErr = err
+				continue
+			}
 			t.AttachBackendTrafficPolicyToUpstream(backend.BackendRef, tctx.BackendTrafficPolicies, upstream)
 			upstream.Nodes = append(upstream.Nodes, upNodes...)
 		}
@@ -443,6 +452,19 @@ func (t *Translator) TranslateHTTPRoute(tctx *provider.TranslateContext, httpRou
 		service.ID = id.GenID(service.Name)
 		service.Hosts = hosts
 		service.Upstream = upstream
+
+		if backendErr != nil && len(upstream.Nodes) == 0 {
+			if service.Plugins == nil {
+				service.Plugins = make(map[string]any)
+			}
+			service.Plugins["fault-injection"] = map[string]any{
+				"abort": map[string]any{
+					"http_status": 500,
+					"body":        "No existing backendRef provided",
+				},
+			}
+		}
+
 		t.fillPluginsFromHTTPRouteFilters(service.Plugins, httpRoute.GetNamespace(), rule.Filters, rule.Matches, tctx)
 
 		matches := rule.Matches

test/conformance/conformance_test.go

@@ -37,11 +37,8 @@ var skippedTestsForTraditionalRoutes = []string{
 	tests.HTTPRouteHostnameIntersection.ShortName,
 	tests.HTTPRouteListenerHostnameMatching.ShortName,
 
-	// tests.HTTPRouteMatching.ShortName,
-	// tests.HTTPRouteMatchingAcrossRoutes.ShortName,
-
 	tests.GatewayInvalidTLSConfiguration.ShortName,
-	tests.HTTPRouteInvalidBackendRefUnknownKind.ShortName,
+	// tests.HTTPRouteInvalidBackendRefUnknownKind.ShortName,
 	tests.HTTPRouteInvalidCrossNamespaceParentRef.ShortName,
 	tests.HTTPRouteInvalidNonExistentBackendRef.ShortName,
 	tests.HTTPRouteInvalidParentRefNotMatchingSectionName.ShortName,