enhancement: adding workload validation logic that mirrors the ComponentBuilder.InState logic. additional workload tests added.

Signed-off-by: Max Whittingham <mwhittingham@redhat.com>

Author: robotmaxtron

pkg/lint/check/validate/workload.go

@@ -5,13 +5,16 @@ import (
 	"fmt"
 	"strconv"
 
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 
+	"github.com/opendatahub-io/odh-cli/pkg/constants"
 	"github.com/opendatahub-io/odh-cli/pkg/lint/check"
 	"github.com/opendatahub-io/odh-cli/pkg/lint/check/result"
 	"github.com/opendatahub-io/odh-cli/pkg/resources"
 	"github.com/opendatahub-io/odh-cli/pkg/util/client"
+	"github.com/opendatahub-io/odh-cli/pkg/util/components"
 	"github.com/opendatahub-io/odh-cli/pkg/util/kube"
 )
 
@@ -40,11 +43,12 @@ type WorkloadConditionFn[T any] func(ctx context.Context, req *WorkloadRequest[T
 // It handles resource listing, CRD-not-found handling, filtering, annotation population,
 // and auto-populating ImpactedObjects.
 type WorkloadBuilder[T kube.NamespacedNamer] struct {
-	check        check.Check
-	target       check.Target
-	resourceType resources.ResourceType
-	listFn       func(ctx context.Context) ([]T, error)
-	filterFn     func(T) (bool, error)
+	check          check.Check
+	target         check.Target
+	resourceType   resources.ResourceType
+	listFn         func(ctx context.Context) ([]T, error)
+	filterFn       func(T) (bool, error)
+	componentNames []string
 }
 
 // Workloads creates a WorkloadBuilder that lists full unstructured objects.
@@ -90,6 +94,17 @@ func (b *WorkloadBuilder[T]) Filter(fn func(T) (bool, error)) *WorkloadBuilder[T
 	return b
 }
 
+// ForComponent specifies the DSC component(s) this workload check requires.
+// If set, Run() verifies at least one component is not in "Removed" state
+// before listing resources. If all components are Removed (or DSC is not found),
+// a passing result is returned indicating no validation is needed.
+// Multiple names use OR semantics (at least one must be active).
+func (b *WorkloadBuilder[T]) ForComponent(names ...string) *WorkloadBuilder[T] {
+	b.componentNames = names
+
+	return b
+}
+
 // Run lists resources, applies the filter, populates annotations, calls the validation function,
 // and auto-populates ImpactedObjects if the mapper did not set them.
 func (b *WorkloadBuilder[T]) Run(
@@ -107,6 +122,18 @@ func (b *WorkloadBuilder[T]) Run(
 		dr.Annotations[check.AnnotationCheckTargetVersion] = b.target.TargetVersion.String()
 	}
 
+	// Check component state precondition if ForComponent was called.
+	if len(b.componentNames) > 0 {
+		earlyResult, err := b.checkComponentState(ctx, dr)
+		if err != nil {
+			return nil, err
+		}
+
+		if earlyResult != nil {
+			return earlyResult, nil
+		}
+	}
+
 	// List resources; treat CRD-not-found as empty list.
 	items, err := b.listFn(ctx)
 	if err != nil && !client.IsResourceTypeNotFound(err) {
@@ -152,6 +179,44 @@ func (b *WorkloadBuilder[T]) Run(
 	return dr, nil
 }
 
+// checkComponentState verifies at least one component is not in Removed state.
+// Returns (result, nil) if validation should short-circuit, or (nil, nil) to continue.
+func (b *WorkloadBuilder[T]) checkComponentState(
+	ctx context.Context,
+	dr *result.DiagnosticResult,
+) (*result.DiagnosticResult, error) {
+	dsc, err := client.GetDataScienceCluster(ctx, b.target.Client)
+	switch {
+	case apierrors.IsNotFound(err):
+		dr.SetCondition(check.NewCondition(
+			check.ConditionTypeAvailable,
+			metav1.ConditionFalse,
+			check.WithReason(check.ReasonResourceNotFound),
+			check.WithMessage("No DataScienceCluster found"),
+		))
+
+		return dr, nil
+	case err != nil:
+		return nil, fmt.Errorf("getting DataScienceCluster: %w", err)
+	}
+
+	// Check if at least one component is active (not Removed).
+	for _, name := range b.componentNames {
+		if !components.HasManagementState(dsc, name, constants.ManagementStateRemoved) {
+			return nil, nil
+		}
+	}
+
+	// All components are Removed - skip workload validation.
+	dr.SetCondition(check.NewCondition(
+		check.ConditionTypeConfigured,
+		metav1.ConditionTrue,
+		check.WithReason(check.ReasonRequirementsMet),
+	))
+
+	return dr, nil
+}
+
 // Complete is a convenience alternative to Run for checks that only need to set conditions.
 // It calls fn to obtain conditions, sets each on the result, and returns.
 func (b *WorkloadBuilder[T]) Complete(

pkg/lint/check/validate/workload_test.go

@@ -14,6 +14,7 @@ import (
 	dynamicfake "k8s.io/client-go/dynamic/fake"
 	metadatafake "k8s.io/client-go/metadata/fake"
 
+	"github.com/opendatahub-io/odh-cli/pkg/constants"
 	"github.com/opendatahub-io/odh-cli/pkg/lint/check"
 	"github.com/opendatahub-io/odh-cli/pkg/lint/check/result"
 	"github.com/opendatahub-io/odh-cli/pkg/lint/check/validate"
@@ -34,6 +35,12 @@ var pytorchJobListKinds = map[schema.GroupVersionResource]string{
 	resources.PyTorchJob.GVR(): resources.PyTorchJob.ListKind(),
 }
 
+//nolint:gochecknoglobals // Test fixture - merged DSC + Notebook list kinds for ForComponent tests
+var dscAndNotebookListKinds = map[schema.GroupVersionResource]string{
+	resources.DataScienceCluster.GVR(): resources.DataScienceCluster.ListKind(),
+	resources.Notebook.GVR():           resources.Notebook.ListKind(),
+}
+
 func newWorkloadTestCheck() *testCheck {
 	return &testCheck{
 		BaseCheck: check.BaseCheck{
@@ -577,3 +584,251 @@ func TestWorkloadBuilder_Complete_ErrorPropagated(t *testing.T) {
 
 	g.Expect(err).To(MatchError(expectedErr))
 }
+
+func TestWorkloadBuilder_ForComponent_RemovedReturnsPassingResult(t *testing.T) {
+	g := NewWithT(t)
+	ctx := t.Context()
+
+	dsc := createDSCWithComponent("kserve", constants.ManagementStateRemoved)
+
+	scheme := runtime.NewScheme()
+	_ = metav1.AddMetaToScheme(scheme)
+	dynamicClient := dynamicfake.NewSimpleDynamicClientWithCustomListKinds(scheme, dscAndNotebookListKinds, dsc)
+	metadataClient := metadatafake.NewSimpleMetadataClient(scheme)
+
+	c := client.NewForTesting(client.TestClientConfig{
+		Dynamic:  dynamicClient,
+		Metadata: metadataClient,
+	})
+
+	chk := newWorkloadTestCheck()
+	chk.Kind = "kserve"
+
+	targetVer := semver.MustParse("3.0.0")
+	target := check.Target{
+		Client:        c,
+		TargetVersion: &targetVer,
+	}
+
+	validationCalled := false
+
+	dr, err := validate.WorkloadsMetadata(chk, target, resources.Notebook).
+		ForComponent("kserve").
+		Run(ctx, func(_ context.Context, _ *validate.WorkloadRequest[*metav1.PartialObjectMetadata]) error {
+			validationCalled = true
+
+			return nil
+		})
+
+	g.Expect(err).ToNot(HaveOccurred())
+	g.Expect(dr).ToNot(BeNil())
+	g.Expect(validationCalled).To(BeFalse())
+	g.Expect(dr.Status.Conditions).To(HaveLen(1))
+	g.Expect(dr.Status.Conditions[0].Type).To(Equal(check.ConditionTypeConfigured))
+	g.Expect(dr.Status.Conditions[0].Status).To(Equal(metav1.ConditionTrue))
+	g.Expect(dr.Status.Conditions[0].Reason).To(Equal(check.ReasonRequirementsMet))
+	g.Expect(dr.Annotations).To(HaveKeyWithValue(check.AnnotationCheckTargetVersion, "3.0.0"))
+}
+
+func TestWorkloadBuilder_ForComponent_ManagedProceedsNormally(t *testing.T) {
+	g := NewWithT(t)
+	ctx := t.Context()
+
+	dsc := createDSCWithComponent("kserve", constants.ManagementStateManaged)
+	nb := &unstructured.Unstructured{
+		Object: map[string]any{
+			"apiVersion": resources.Notebook.APIVersion(),
+			"kind":       resources.Notebook.Kind,
+			"metadata":   map[string]any{"name": "nb-1", "namespace": "ns1"},
+		},
+	}
+
+	scheme := runtime.NewScheme()
+	_ = metav1.AddMetaToScheme(scheme)
+	dynamicClient := dynamicfake.NewSimpleDynamicClientWithCustomListKinds(scheme, dscAndNotebookListKinds, dsc, nb)
+	metadataClient := metadatafake.NewSimpleMetadataClient(scheme, kube.ToPartialObjectMetadata(nb)...)
+
+	c := client.NewForTesting(client.TestClientConfig{
+		Dynamic:  dynamicClient,
+		Metadata: metadataClient,
+	})
+
+	chk := newWorkloadTestCheck()
+	chk.Kind = "kserve"
+
+	targetVer := semver.MustParse("3.0.0")
+	target := check.Target{
+		Client:        c,
+		TargetVersion: &targetVer,
+	}
+
+	validationCalled := false
+
+	dr, err := validate.WorkloadsMetadata(chk, target, resources.Notebook).
+		ForComponent("kserve").
+		Run(ctx, func(_ context.Context, req *validate.WorkloadRequest[*metav1.PartialObjectMetadata]) error {
+			validationCalled = true
+			g.Expect(req.Items).To(HaveLen(1))
+			req.Result.SetCondition(check.NewCondition(
+				check.ConditionTypeCompatible,
+				metav1.ConditionTrue,
+				check.WithReason(check.ReasonVersionCompatible),
+				check.WithMessage("Found %d notebooks", len(req.Items)),
+			))
+
+			return nil
+		})
+
+	g.Expect(err).ToNot(HaveOccurred())
+	g.Expect(dr).ToNot(BeNil())
+	g.Expect(validationCalled).To(BeTrue())
+	g.Expect(dr.Status.Conditions).To(HaveLen(1))
+	g.Expect(dr.Status.Conditions[0].Type).To(Equal(check.ConditionTypeCompatible))
+}
+
+func TestWorkloadBuilder_ForComponent_DSCNotFound(t *testing.T) {
+	g := NewWithT(t)
+	ctx := t.Context()
+
+	// No DSC in the cluster.
+	scheme := runtime.NewScheme()
+	_ = metav1.AddMetaToScheme(scheme)
+	dynamicClient := dynamicfake.NewSimpleDynamicClientWithCustomListKinds(scheme, dscAndNotebookListKinds)
+	metadataClient := metadatafake.NewSimpleMetadataClient(scheme)
+
+	c := client.NewForTesting(client.TestClientConfig{
+		Dynamic:  dynamicClient,
+		Metadata: metadataClient,
+	})
+
+	chk := newWorkloadTestCheck()
+	chk.Kind = "kserve"
+
+	target := check.Target{
+		Client: c,
+	}
+
+	validationCalled := false
+
+	dr, err := validate.WorkloadsMetadata(chk, target, resources.Notebook).
+		ForComponent("kserve").
+		Run(ctx, func(_ context.Context, _ *validate.WorkloadRequest[*metav1.PartialObjectMetadata]) error {
+			validationCalled = true
+
+			return nil
+		})
+
+	g.Expect(err).ToNot(HaveOccurred())
+	g.Expect(dr).ToNot(BeNil())
+	g.Expect(validationCalled).To(BeFalse())
+	g.Expect(dr.Status.Conditions).To(HaveLen(1))
+	g.Expect(dr.Status.Conditions[0].Type).To(Equal(check.ConditionTypeAvailable))
+	g.Expect(dr.Status.Conditions[0].Status).To(Equal(metav1.ConditionFalse))
+	g.Expect(dr.Status.Conditions[0].Reason).To(Equal(check.ReasonResourceNotFound))
+}
+
+func TestWorkloadBuilder_ForComponent_MultipleComponentsORSemantics(t *testing.T) {
+	g := NewWithT(t)
+	ctx := t.Context()
+
+	// DSC with kserve Removed but modelmesh Managed - at least one is active.
+	dsc := &unstructured.Unstructured{
+		Object: map[string]any{
+			"apiVersion": resources.DataScienceCluster.APIVersion(),
+			"kind":       resources.DataScienceCluster.Kind,
+			"metadata":   map[string]any{"name": "default-dsc"},
+			"spec": map[string]any{
+				"components": map[string]any{
+					"kserve":    map[string]any{"managementState": constants.ManagementStateRemoved},
+					"modelmesh": map[string]any{"managementState": constants.ManagementStateManaged},
+				},
+			},
+		},
+	}
+
+	scheme := runtime.NewScheme()
+	_ = metav1.AddMetaToScheme(scheme)
+	dynamicClient := dynamicfake.NewSimpleDynamicClientWithCustomListKinds(scheme, dscAndNotebookListKinds, dsc)
+	metadataClient := metadatafake.NewSimpleMetadataClient(scheme)
+
+	c := client.NewForTesting(client.TestClientConfig{
+		Dynamic:  dynamicClient,
+		Metadata: metadataClient,
+	})
+
+	chk := newWorkloadTestCheck()
+
+	target := check.Target{
+		Client: c,
+	}
+
+	validationCalled := false
+
+	dr, err := validate.WorkloadsMetadata(chk, target, resources.Notebook).
+		ForComponent("kserve", "modelmesh").
+		Run(ctx, func(_ context.Context, req *validate.WorkloadRequest[*metav1.PartialObjectMetadata]) error {
+			validationCalled = true
+			req.Result.SetCondition(check.NewCondition(
+				check.ConditionTypeCompatible,
+				metav1.ConditionTrue,
+				check.WithReason(check.ReasonVersionCompatible),
+				check.WithMessage("Validation proceeded"),
+			))
+
+			return nil
+		})
+
+	g.Expect(err).ToNot(HaveOccurred())
+	g.Expect(dr).ToNot(BeNil())
+	g.Expect(validationCalled).To(BeTrue())
+}
+
+func TestWorkloadBuilder_NoForComponent_BackwardCompatible(t *testing.T) {
+	g := NewWithT(t)
+	ctx := t.Context()
+
+	nb := &unstructured.Unstructured{
+		Object: map[string]any{
+			"apiVersion": resources.Notebook.APIVersion(),
+			"kind":       resources.Notebook.Kind,
+			"metadata":   map[string]any{"name": "nb-1", "namespace": "ns1"},
+		},
+	}
+
+	scheme := runtime.NewScheme()
+	_ = metav1.AddMetaToScheme(scheme)
+	dynamicClient := dynamicfake.NewSimpleDynamicClientWithCustomListKinds(scheme, notebookListKinds, nb)
+	metadataClient := metadatafake.NewSimpleMetadataClient(scheme, kube.ToPartialObjectMetadata(nb)...)
+
+	c := client.NewForTesting(client.TestClientConfig{
+		Dynamic:  dynamicClient,
+		Metadata: metadataClient,
+	})
+
+	chk := newWorkloadTestCheck()
+	target := check.Target{
+		Client: c,
+	}
+
+	// No ForComponent() called - should proceed without checking DSC.
+	validationCalled := false
+
+	dr, err := validate.WorkloadsMetadata(chk, target, resources.Notebook).
+		Run(ctx, func(_ context.Context, req *validate.WorkloadRequest[*metav1.PartialObjectMetadata]) error {
+			validationCalled = true
+			g.Expect(req.Items).To(HaveLen(1))
+			req.Result.SetCondition(check.NewCondition(
+				check.ConditionTypeCompatible,
+				metav1.ConditionTrue,
+				check.WithReason(check.ReasonVersionCompatible),
+				check.WithMessage("No component check"),
+			))
+
+			return nil
+		})
+
+	g.Expect(err).ToNot(HaveOccurred())
+	g.Expect(dr).ToNot(BeNil())
+	g.Expect(validationCalled).To(BeTrue())
+	g.Expect(dr.Status.Conditions).To(HaveLen(1))
+}