From b12edf84c67511c07606dedd802eacc05ad8ee02 Mon Sep 17 00:00:00 2001 From: Harsh Date: Wed, 28 Jan 2026 09:12:30 +0530 Subject: [PATCH 1/4] test(thin): migrate worker tests to ginkgo Signed-off-by: Harsh --- pkg/ddc/thin/worker_test.go | 856 ++++++++++++++++++------------------ 1 file changed, 419 insertions(+), 437 deletions(-) diff --git a/pkg/ddc/thin/worker_test.go b/pkg/ddc/thin/worker_test.go index bc6725f9be8..51784d3f0bd 100644 --- a/pkg/ddc/thin/worker_test.go +++ b/pkg/ddc/thin/worker_test.go @@ -17,471 +17,453 @@ package thin import ( - "testing" - datav1alpha1 "github.com/fluid-cloudnative/fluid/api/v1alpha1" "github.com/fluid-cloudnative/fluid/pkg/common" ctrlhelper "github.com/fluid-cloudnative/fluid/pkg/ctrl" "github.com/fluid-cloudnative/fluid/pkg/ddc/base" "github.com/fluid-cloudnative/fluid/pkg/utils/fake" + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" appsv1 "k8s.io/api/apps/v1" v1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/runtime" + runtimeschema "k8s.io/apimachinery/pkg/runtime" "k8s.io/utils/ptr" ctrl "sigs.k8s.io/controller-runtime" ) -func TestThinEngine_ShouldSetupWorkers(t *testing.T) { - type fields struct { - name string - namespace string - runtime *datav1alpha1.ThinRuntime - } - tests := []struct { - name string - fields fields - wantShould bool - wantErr bool - }{ - { - name: "test0", - fields: fields{ - name: "test0", - namespace: "thin", - runtime: &datav1alpha1.ThinRuntime{ - ObjectMeta: metav1.ObjectMeta{ - Name: "test0", - Namespace: "thin", - }, - Spec: datav1alpha1.ThinRuntimeSpec{ - Worker: datav1alpha1.ThinCompTemplateSpec{ - Enabled: true, - }, - }, - Status: datav1alpha1.RuntimeStatus{ - WorkerPhase: datav1alpha1.RuntimePhaseNone, - }, - }, +var _ = Describe("ThinEngine_ShouldSetupWorkers", func() { + It("should return true when worker phase is None and worker is enabled", func() { + runtime := &datav1alpha1.ThinRuntime{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test0", + Namespace: "thin", }, - wantShould: true, - wantErr: false, - }, - { - name: "test1", - fields: fields{ - name: "test1", - namespace: "thin", - runtime: &datav1alpha1.ThinRuntime{ - ObjectMeta: metav1.ObjectMeta{ - Name: "test1", - Namespace: "thin", - }, - Spec: datav1alpha1.ThinRuntimeSpec{ - Worker: datav1alpha1.ThinCompTemplateSpec{ - Enabled: true, - }, - }, - Status: datav1alpha1.RuntimeStatus{ - WorkerPhase: datav1alpha1.RuntimePhaseNotReady, - }, + Spec: datav1alpha1.ThinRuntimeSpec{ + Worker: datav1alpha1.ThinCompTemplateSpec{ + Enabled: true, }, }, - wantShould: false, - wantErr: false, - }, - { - name: "test2", - fields: fields{ - name: "test2", - namespace: "thin", - runtime: &datav1alpha1.ThinRuntime{ - ObjectMeta: metav1.ObjectMeta{ - Name: "test2", - Namespace: "thin", - }, - Spec: datav1alpha1.ThinRuntimeSpec{ - Worker: datav1alpha1.ThinCompTemplateSpec{ - Enabled: true, - }, - }, - Status: datav1alpha1.RuntimeStatus{ - WorkerPhase: datav1alpha1.RuntimePhasePartialReady, - }, - }, + Status: datav1alpha1.RuntimeStatus{ + WorkerPhase: datav1alpha1.RuntimePhaseNone, }, - wantShould: false, - wantErr: false, - }, - { - name: "test3", - fields: fields{ - name: "test3", - namespace: "thin", - runtime: &datav1alpha1.ThinRuntime{ - ObjectMeta: metav1.ObjectMeta{ - Name: "test3", - Namespace: "thin", - }, - Spec: datav1alpha1.ThinRuntimeSpec{ - Worker: datav1alpha1.ThinCompTemplateSpec{ - Enabled: true, - }, - }, - Status: datav1alpha1.RuntimeStatus{ - WorkerPhase: datav1alpha1.RuntimePhaseReady, - }, - }, + } + + data := &datav1alpha1.Dataset{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test0", + Namespace: "thin", }, - wantShould: false, - wantErr: false, - }, - { - name: "test4", - fields: fields{ - name: "test3", - namespace: "thin", - runtime: &datav1alpha1.ThinRuntime{ - ObjectMeta: metav1.ObjectMeta{ - Name: "test3", - Namespace: "thin", - }, - }, + } + + s := runtimeschema.NewScheme() + s.AddKnownTypes(datav1alpha1.GroupVersion, runtime, data) + _ = v1.AddToScheme(s) + + mockClient := fake.NewFakeClientWithScheme(s, runtime, data) + + e := &ThinEngine{ + name: "test0", + namespace: "thin", + runtime: runtime, + Client: mockClient, + } + + gotShould, err := e.ShouldSetupWorkers() + + Expect(err).NotTo(HaveOccurred()) + Expect(gotShould).To(BeTrue()) + }) + + It("should return false when worker phase is NotReady", func() { + runtime := &datav1alpha1.ThinRuntime{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test1", + Namespace: "thin", }, - wantShould: false, - wantErr: false, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - runtimeObjs := []runtime.Object{} - data := &datav1alpha1.Dataset{ - ObjectMeta: metav1.ObjectMeta{ - Name: tt.fields.name, - Namespace: tt.fields.namespace, + Spec: datav1alpha1.ThinRuntimeSpec{ + Worker: datav1alpha1.ThinCompTemplateSpec{ + Enabled: true, }, - } - - s := runtime.NewScheme() - s.AddKnownTypes(datav1alpha1.GroupVersion, tt.fields.runtime) - s.AddKnownTypes(datav1alpha1.GroupVersion, data) - _ = v1.AddToScheme(s) - runtimeObjs = append(runtimeObjs, tt.fields.runtime, data) - mockClient := fake.NewFakeClientWithScheme(s, runtimeObjs...) - e := &ThinEngine{ - name: tt.fields.name, - namespace: tt.fields.namespace, - runtime: tt.fields.runtime, - Client: mockClient, - } - - gotShould, err := e.ShouldSetupWorkers() - if (err != nil) != tt.wantErr { - t.Errorf("ThinEngine.ShouldSetupWorkers() error = %v, wantErr %v", err, tt.wantErr) - return - } - if gotShould != tt.wantShould { - t.Errorf("ThinEngine.ShouldSetupWorkers() = %v, want %v", gotShould, tt.wantShould) - } - }) - } -} + }, + Status: datav1alpha1.RuntimeStatus{ + WorkerPhase: datav1alpha1.RuntimePhaseNotReady, + }, + } -func TestThinEngine_SetupWorkers(t *testing.T) { - runtimeInfo, err := base.BuildRuntimeInfo("thin", "fluid", common.ThinRuntime) + data := &datav1alpha1.Dataset{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test1", + Namespace: "thin", + }, + } + + s := runtimeschema.NewScheme() + s.AddKnownTypes(datav1alpha1.GroupVersion, runtime, data) + _ = v1.AddToScheme(s) + + mockClient := fake.NewFakeClientWithScheme(s, runtime, data) + + e := &ThinEngine{ + name: "test1", + namespace: "thin", + runtime: runtime, + Client: mockClient, + } - if err != nil { - t.Errorf("fail to create the runtimeInfo with error %v", err) - } - runtimeInfo.SetupWithDataset(&datav1alpha1.Dataset{ - Spec: datav1alpha1.DatasetSpec{PlacementMode: datav1alpha1.ExclusiveMode}, + gotShould, err := e.ShouldSetupWorkers() + + Expect(err).NotTo(HaveOccurred()) + Expect(gotShould).To(BeFalse()) }) - nodeSelector := map[string]string{ - "node-select": "true", - } - runtimeInfo.SetFuseNodeSelector(nodeSelector) - - type fields struct { - replicas int32 - nodeInputs []*v1.Node - worker appsv1.StatefulSet - runtime *datav1alpha1.ThinRuntime - runtimeInfo base.RuntimeInfoInterface - name string - namespace string - } - tests := []struct { - name string - fields fields - wantedNodeLabels map[string]map[string]string - }{ - { - name: "test0", - fields: fields{ - replicas: 1, - nodeInputs: []*v1.Node{ - { - ObjectMeta: metav1.ObjectMeta{ - Name: "test-node", - }, - }, - }, - worker: appsv1.StatefulSet{ - ObjectMeta: metav1.ObjectMeta{ - Name: "test-worker", - Namespace: "fluid", - }, - Spec: appsv1.StatefulSetSpec{ - Replicas: ptr.To[int32](1), - }, - }, - runtime: &datav1alpha1.ThinRuntime{ - ObjectMeta: metav1.ObjectMeta{ - Name: "test", - Namespace: "fluid", - }, - Spec: datav1alpha1.ThinRuntimeSpec{ - Replicas: 1, - }, - }, - runtimeInfo: runtimeInfo, - name: "test", - namespace: "fluid", - }, - wantedNodeLabels: map[string]map[string]string{ - "test-node": { - "fluid.io/dataset-num": "1", - "fluid.io/s-fluid-thin": "true", - "fluid.io/s-h-thin-t-fluid-thin": "0B", - "fluid.io/s-thin-fluid-thin": "true", - "fluid_exclusive": "fluid_thin", + It("should return false when worker phase is PartialReady", func() { + runtime := &datav1alpha1.ThinRuntime{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test2", + Namespace: "thin", + }, + Spec: datav1alpha1.ThinRuntimeSpec{ + Worker: datav1alpha1.ThinCompTemplateSpec{ + Enabled: true, }, }, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - runtimeObjs := []runtime.Object{} - for _, nodeInput := range tt.fields.nodeInputs { - runtimeObjs = append(runtimeObjs, nodeInput.DeepCopy()) - } - runtimeObjs = append(runtimeObjs, tt.fields.worker.DeepCopy()) - - s := runtime.NewScheme() - data := &datav1alpha1.Dataset{ - ObjectMeta: metav1.ObjectMeta{ - Name: tt.fields.name, - Namespace: tt.fields.namespace, + Status: datav1alpha1.RuntimeStatus{ + WorkerPhase: datav1alpha1.RuntimePhasePartialReady, + }, + } + + data := &datav1alpha1.Dataset{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test2", + Namespace: "thin", + }, + } + + s := runtimeschema.NewScheme() + s.AddKnownTypes(datav1alpha1.GroupVersion, runtime, data) + _ = v1.AddToScheme(s) + + mockClient := fake.NewFakeClientWithScheme(s, runtime, data) + + e := &ThinEngine{ + name: "test2", + namespace: "thin", + runtime: runtime, + Client: mockClient, + } + + gotShould, err := e.ShouldSetupWorkers() + + Expect(err).NotTo(HaveOccurred()) + Expect(gotShould).To(BeFalse()) + }) + + It("should return false when worker phase is Ready", func() { + runtime := &datav1alpha1.ThinRuntime{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test3", + Namespace: "thin", + }, + Spec: datav1alpha1.ThinRuntimeSpec{ + Worker: datav1alpha1.ThinCompTemplateSpec{ + Enabled: true, }, - } - s.AddKnownTypes(datav1alpha1.GroupVersion, tt.fields.runtime) - s.AddKnownTypes(datav1alpha1.GroupVersion, data) - s.AddKnownTypes(appsv1.SchemeGroupVersion, &tt.fields.worker) - _ = v1.AddToScheme(s) - runtimeObjs = append(runtimeObjs, tt.fields.runtime) - runtimeObjs = append(runtimeObjs, data) - mockClient := fake.NewFakeClientWithScheme(s, runtimeObjs...) - - e := &ThinEngine{ - runtime: tt.fields.runtime, - runtimeInfo: tt.fields.runtimeInfo, - Client: mockClient, - name: tt.fields.name, - namespace: tt.fields.namespace, - Log: ctrl.Log.WithName(tt.fields.name), - } - - e.Helper = ctrlhelper.BuildHelper(runtimeInfo, mockClient, e.Log) - err = e.SetupWorkers() - if err != nil { - t.Errorf("ThinEngine.SetupWorkers() error = %v", err) - } - if tt.fields.replicas != *tt.fields.worker.Spec.Replicas { - t.Errorf("Failed to scale %v for %v", tt.name, tt.fields) - } + }, + Status: datav1alpha1.RuntimeStatus{ + WorkerPhase: datav1alpha1.RuntimePhaseReady, + }, + } + + data := &datav1alpha1.Dataset{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test3", + Namespace: "thin", + }, + } + + s := runtimeschema.NewScheme() + s.AddKnownTypes(datav1alpha1.GroupVersion, runtime, data) + _ = v1.AddToScheme(s) + + mockClient := fake.NewFakeClientWithScheme(s, runtime, data) + + e := &ThinEngine{ + name: "test3", + namespace: "thin", + runtime: runtime, + Client: mockClient, + } + + gotShould, err := e.ShouldSetupWorkers() + + Expect(err).NotTo(HaveOccurred()) + Expect(gotShould).To(BeFalse()) + }) + + It("should return false when worker is not enabled", func() { + runtime := &datav1alpha1.ThinRuntime{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test3", + Namespace: "thin", + }, + } + + data := &datav1alpha1.Dataset{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test3", + Namespace: "thin", + }, + } + + s := runtimeschema.NewScheme() + s.AddKnownTypes(datav1alpha1.GroupVersion, runtime, data) + _ = v1.AddToScheme(s) + + mockClient := fake.NewFakeClientWithScheme(s, runtime, data) + + e := &ThinEngine{ + name: "test3", + namespace: "thin", + runtime: runtime, + Client: mockClient, + } + + gotShould, err := e.ShouldSetupWorkers() + + Expect(err).NotTo(HaveOccurred()) + Expect(gotShould).To(BeFalse()) + }) +}) + +var _ = Describe("ThinEngine_SetupWorkers", func() { + It("should setup workers and scale correctly", func() { + runtimeInfo, err := base.BuildRuntimeInfo("thin", "fluid", common.ThinRuntime) + Expect(err).NotTo(HaveOccurred()) + + runtimeInfo.SetupWithDataset(&datav1alpha1.Dataset{ + Spec: datav1alpha1.DatasetSpec{PlacementMode: datav1alpha1.ExclusiveMode}, }) - } -} - -func TestThinEngine_CheckWorkersReady(t *testing.T) { - type fields struct { - runtime *datav1alpha1.ThinRuntime - fuse *appsv1.DaemonSet - worker *appsv1.StatefulSet - name string - namespace string - } - tests := []struct { - name string - fields fields - wantReady bool - wantErr bool - }{ - { - name: "test0", - fields: fields{ - name: "test0", - namespace: "thin", - runtime: &datav1alpha1.ThinRuntime{ - ObjectMeta: metav1.ObjectMeta{ - Name: "test0", - Namespace: "thin", - }, - Spec: datav1alpha1.ThinRuntimeSpec{ - Replicas: 1, - Worker: datav1alpha1.ThinCompTemplateSpec{ - Enabled: true, - }, - Fuse: datav1alpha1.ThinFuseSpec{}, - }, - }, - worker: &appsv1.StatefulSet{ - ObjectMeta: metav1.ObjectMeta{ - Name: "test0-worker", - Namespace: "thin", - }, - Spec: appsv1.StatefulSetSpec{ - Replicas: ptr.To[int32](1), - }, - Status: appsv1.StatefulSetStatus{ - Replicas: 1, - ReadyReplicas: 1, - }, - }, - fuse: &appsv1.DaemonSet{ - ObjectMeta: metav1.ObjectMeta{ - Name: "test0-fuse", - Namespace: "thin", - }, - Status: appsv1.DaemonSetStatus{ - NumberAvailable: 1, - DesiredNumberScheduled: 1, - CurrentNumberScheduled: 1, - }, - }, + + nodeSelector := map[string]string{ + "node-select": "true", + } + runtimeInfo.SetFuseNodeSelector(nodeSelector) + + node := &v1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-node", }, - wantReady: true, - wantErr: false, - }, - { - name: "test1", - fields: fields{ - name: "test1", - namespace: "thin", - runtime: &datav1alpha1.ThinRuntime{ - ObjectMeta: metav1.ObjectMeta{ - Name: "test1", - Namespace: "thin", - }, - Spec: datav1alpha1.ThinRuntimeSpec{ - Replicas: 1, - Worker: datav1alpha1.ThinCompTemplateSpec{ - Enabled: true, - }, - Fuse: datav1alpha1.ThinFuseSpec{}, - }, - }, - worker: &appsv1.StatefulSet{ - ObjectMeta: metav1.ObjectMeta{ - Name: "test1-worker", - Namespace: "thin", - }, - Spec: appsv1.StatefulSetSpec{ - Replicas: ptr.To[int32](1), - }, - Status: appsv1.StatefulSetStatus{ - Replicas: 1, - ReadyReplicas: 0, - }, - }, - fuse: &appsv1.DaemonSet{ - ObjectMeta: metav1.ObjectMeta{ - Name: "test1-fuse", - Namespace: "thin", - }, - Status: appsv1.DaemonSetStatus{ - NumberAvailable: 0, - DesiredNumberScheduled: 1, - CurrentNumberScheduled: 0, - }, + } + + worker := appsv1.StatefulSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-worker", + Namespace: "fluid", + }, + Spec: appsv1.StatefulSetSpec{ + Replicas: ptr.To[int32](1), + }, + } + + runtime := &datav1alpha1.ThinRuntime{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test", + Namespace: "fluid", + }, + Spec: datav1alpha1.ThinRuntimeSpec{ + Replicas: 1, + }, + } + + s := runtimeschema.NewScheme() + data := &datav1alpha1.Dataset{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test", + Namespace: "fluid", + }, + } + s.AddKnownTypes(datav1alpha1.GroupVersion, runtime, data) + s.AddKnownTypes(appsv1.SchemeGroupVersion, &worker) + _ = v1.AddToScheme(s) + + mockClient := fake.NewFakeClientWithScheme(s, node.DeepCopy(), worker.DeepCopy(), runtime, data) + + e := &ThinEngine{ + runtime: runtime, + runtimeInfo: runtimeInfo, + Client: mockClient, + name: "test", + namespace: "fluid", + Log: ctrl.Log.WithName("test"), + } + + e.Helper = ctrlhelper.BuildHelper(runtimeInfo, mockClient, e.Log) + + err = e.SetupWorkers() + Expect(err).NotTo(HaveOccurred()) + Expect(*worker.Spec.Replicas).To(Equal(int32(1))) + }) +}) + +var _ = Describe("ThinEngine_CheckWorkersReady", func() { + It("should return true when workers and fuse are ready", func() { + runtime := &datav1alpha1.ThinRuntime{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test0", + Namespace: "thin", + }, + Spec: datav1alpha1.ThinRuntimeSpec{ + Replicas: 1, + Worker: datav1alpha1.ThinCompTemplateSpec{ + Enabled: true, }, + Fuse: datav1alpha1.ThinFuseSpec{}, + }, + } + + worker := &appsv1.StatefulSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test0-worker", + Namespace: "thin", + }, + Spec: appsv1.StatefulSetSpec{ + Replicas: ptr.To[int32](1), + }, + Status: appsv1.StatefulSetStatus{ + Replicas: 1, + ReadyReplicas: 1, + }, + } + + fuse := &appsv1.DaemonSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test0-fuse", + Namespace: "thin", }, - wantReady: false, - wantErr: false, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - runtimeObjs := []runtime.Object{} - data := &datav1alpha1.Dataset{ - ObjectMeta: metav1.ObjectMeta{ - Name: tt.fields.name, - Namespace: tt.fields.namespace, + Status: appsv1.DaemonSetStatus{ + NumberAvailable: 1, + DesiredNumberScheduled: 1, + CurrentNumberScheduled: 1, + }, + } + + data := &datav1alpha1.Dataset{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test0", + Namespace: "thin", + }, + } + + s := runtimeschema.NewScheme() + s.AddKnownTypes(datav1alpha1.GroupVersion, runtime, data) + s.AddKnownTypes(appsv1.SchemeGroupVersion, fuse, worker) + _ = v1.AddToScheme(s) + + mockClient := fake.NewFakeClientWithScheme(s, runtime, data, fuse, worker) + + e := &ThinEngine{ + runtime: runtime, + name: "test0", + namespace: "thin", + Client: mockClient, + Log: ctrl.Log.WithName("test0"), + } + + runtimeInfo, err := base.BuildRuntimeInfo("test0", "thin", common.ThinRuntime) + Expect(err).NotTo(HaveOccurred()) + + e.Helper = ctrlhelper.BuildHelper(runtimeInfo, mockClient, e.Log) + + gotReady, err := e.CheckWorkersReady() + + Expect(err).NotTo(HaveOccurred()) + Expect(gotReady).To(BeTrue()) + }) + + It("should return false when workers are not ready", func() { + runtime := &datav1alpha1.ThinRuntime{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test1", + Namespace: "thin", + }, + Spec: datav1alpha1.ThinRuntimeSpec{ + Replicas: 1, + Worker: datav1alpha1.ThinCompTemplateSpec{ + Enabled: true, }, - } - - s := runtime.NewScheme() - s.AddKnownTypes(datav1alpha1.GroupVersion, tt.fields.runtime) - s.AddKnownTypes(datav1alpha1.GroupVersion, data) - s.AddKnownTypes(appsv1.SchemeGroupVersion, tt.fields.fuse) - s.AddKnownTypes(appsv1.SchemeGroupVersion, tt.fields.worker) - _ = v1.AddToScheme(s) - - runtimeObjs = append(runtimeObjs, tt.fields.runtime, data, tt.fields.fuse, tt.fields.worker) - mockClient := fake.NewFakeClientWithScheme(s, runtimeObjs...) - e := &ThinEngine{ - runtime: tt.fields.runtime, - name: tt.fields.name, - namespace: tt.fields.namespace, - Client: mockClient, - Log: ctrl.Log.WithName(tt.fields.name), - } - runtimeInfo, err := base.BuildRuntimeInfo(tt.fields.name, tt.fields.namespace, common.ThinRuntime) - if err != nil { - t.Errorf("ThinEngine.CheckWorkersReady() error = %v", err) - } - - e.Helper = ctrlhelper.BuildHelper(runtimeInfo, mockClient, e.Log) - - gotReady, err := e.CheckWorkersReady() - if (err != nil) != tt.wantErr { - t.Errorf("ThinEngine.CheckWorkersReady() error = %v, wantErr %v", err, tt.wantErr) - return - } - if gotReady != tt.wantReady { - t.Errorf("ThinEngine.CheckWorkersReady() = %v, want %v", gotReady, tt.wantReady) - } - }) - } -} - -func TestThinEngine_GetWorkerSelectors(t *testing.T) { - type fields struct { - name string - } - tests := []struct { - name string - fields fields - want string - }{ - { - name: "test0", - fields: fields{ - name: "spark", - }, - want: "app=thin,release=spark,role=thin-worker", - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - e := &ThinEngine{ - name: tt.fields.name, - } - if got := e.getWorkerSelectors(); got != tt.want { - t.Errorf("ThinEngine.getWorkerSelectors() = %v, want %v", got, tt.want) - } - }) - } -} + Fuse: datav1alpha1.ThinFuseSpec{}, + }, + } + + worker := &appsv1.StatefulSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test1-worker", + Namespace: "thin", + }, + Spec: appsv1.StatefulSetSpec{ + Replicas: ptr.To[int32](1), + }, + Status: appsv1.StatefulSetStatus{ + Replicas: 1, + ReadyReplicas: 0, + }, + } + + fuse := &appsv1.DaemonSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test1-fuse", + Namespace: "thin", + }, + Status: appsv1.DaemonSetStatus{ + NumberAvailable: 0, + DesiredNumberScheduled: 1, + CurrentNumberScheduled: 0, + }, + } + + data := &datav1alpha1.Dataset{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test1", + Namespace: "thin", + }, + } + + s := runtimeschema.NewScheme() + s.AddKnownTypes(datav1alpha1.GroupVersion, runtime, data) + s.AddKnownTypes(appsv1.SchemeGroupVersion, fuse, worker) + _ = v1.AddToScheme(s) + + mockClient := fake.NewFakeClientWithScheme(s, runtime, data, fuse, worker) + + e := &ThinEngine{ + runtime: runtime, + name: "test1", + namespace: "thin", + Client: mockClient, + Log: ctrl.Log.WithName("test1"), + } + + runtimeInfo, err := base.BuildRuntimeInfo("test1", "thin", common.ThinRuntime) + Expect(err).NotTo(HaveOccurred()) + + e.Helper = ctrlhelper.BuildHelper(runtimeInfo, mockClient, e.Log) + + gotReady, err := e.CheckWorkersReady() + + Expect(err).NotTo(HaveOccurred()) + Expect(gotReady).To(BeFalse()) + }) +}) + +var _ = Describe("ThinEngine_GetWorkerSelectors", func() { + It("should return correct worker selector", func() { + e := &ThinEngine{ + name: "spark", + } + + got := e.getWorkerSelectors() + + Expect(got).To(Equal("app=thin,release=spark,role=thin-worker")) + }) +}) From 36664d555448387ebce86f0f879c59668f93ffba Mon Sep 17 00:00:00 2001 From: Harsh Date: Wed, 28 Jan 2026 16:48:58 +0530 Subject: [PATCH 2/4] fix: enable worker + fetch from client + suite package + import alias Signed-off-by: Harsh --- pkg/ddc/thin/thin_suite_test.go | 2 +- pkg/ddc/thin/worker_test.go | 30 ++++++++++++++++++++---------- 2 files changed, 21 insertions(+), 11 deletions(-) diff --git a/pkg/ddc/thin/thin_suite_test.go b/pkg/ddc/thin/thin_suite_test.go index 18031042fb6..53a7eb8a444 100644 --- a/pkg/ddc/thin/thin_suite_test.go +++ b/pkg/ddc/thin/thin_suite_test.go @@ -1,4 +1,4 @@ -package thin_test +package thin import ( "testing" diff --git a/pkg/ddc/thin/worker_test.go b/pkg/ddc/thin/worker_test.go index 51784d3f0bd..e47cf02c694 100644 --- a/pkg/ddc/thin/worker_test.go +++ b/pkg/ddc/thin/worker_test.go @@ -17,6 +17,8 @@ package thin import ( + "context" + datav1alpha1 "github.com/fluid-cloudnative/fluid/api/v1alpha1" "github.com/fluid-cloudnative/fluid/pkg/common" ctrlhelper "github.com/fluid-cloudnative/fluid/pkg/ctrl" @@ -27,9 +29,10 @@ import ( appsv1 "k8s.io/api/apps/v1" v1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - runtimeschema "k8s.io/apimachinery/pkg/runtime" + apimachineryruntime "k8s.io/apimachinery/pkg/runtime" "k8s.io/utils/ptr" ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/client" ) var _ = Describe("ThinEngine_ShouldSetupWorkers", func() { @@ -56,7 +59,7 @@ var _ = Describe("ThinEngine_ShouldSetupWorkers", func() { }, } - s := runtimeschema.NewScheme() + s := apimachineryruntime.NewScheme() s.AddKnownTypes(datav1alpha1.GroupVersion, runtime, data) _ = v1.AddToScheme(s) @@ -98,7 +101,7 @@ var _ = Describe("ThinEngine_ShouldSetupWorkers", func() { }, } - s := runtimeschema.NewScheme() + s := apimachineryruntime.NewScheme() s.AddKnownTypes(datav1alpha1.GroupVersion, runtime, data) _ = v1.AddToScheme(s) @@ -140,7 +143,7 @@ var _ = Describe("ThinEngine_ShouldSetupWorkers", func() { }, } - s := runtimeschema.NewScheme() + s := apimachineryruntime.NewScheme() s.AddKnownTypes(datav1alpha1.GroupVersion, runtime, data) _ = v1.AddToScheme(s) @@ -182,7 +185,7 @@ var _ = Describe("ThinEngine_ShouldSetupWorkers", func() { }, } - s := runtimeschema.NewScheme() + s := apimachineryruntime.NewScheme() s.AddKnownTypes(datav1alpha1.GroupVersion, runtime, data) _ = v1.AddToScheme(s) @@ -216,7 +219,7 @@ var _ = Describe("ThinEngine_ShouldSetupWorkers", func() { }, } - s := runtimeschema.NewScheme() + s := apimachineryruntime.NewScheme() s.AddKnownTypes(datav1alpha1.GroupVersion, runtime, data) _ = v1.AddToScheme(s) @@ -273,10 +276,13 @@ var _ = Describe("ThinEngine_SetupWorkers", func() { }, Spec: datav1alpha1.ThinRuntimeSpec{ Replicas: 1, + Worker: datav1alpha1.ThinCompTemplateSpec{ + Enabled: true, + }, }, } - s := runtimeschema.NewScheme() + s := apimachineryruntime.NewScheme() data := &datav1alpha1.Dataset{ ObjectMeta: metav1.ObjectMeta{ Name: "test", @@ -302,7 +308,11 @@ var _ = Describe("ThinEngine_SetupWorkers", func() { err = e.SetupWorkers() Expect(err).NotTo(HaveOccurred()) - Expect(*worker.Spec.Replicas).To(Equal(int32(1))) + + var updatedWorker appsv1.StatefulSet + err = mockClient.Get(context.TODO(), client.ObjectKey{Name: "test-worker", Namespace: "fluid"}, &updatedWorker) + Expect(err).NotTo(HaveOccurred()) + Expect(*updatedWorker.Spec.Replicas).To(Equal(int32(1))) }) }) @@ -355,7 +365,7 @@ var _ = Describe("ThinEngine_CheckWorkersReady", func() { }, } - s := runtimeschema.NewScheme() + s := apimachineryruntime.NewScheme() s.AddKnownTypes(datav1alpha1.GroupVersion, runtime, data) s.AddKnownTypes(appsv1.SchemeGroupVersion, fuse, worker) _ = v1.AddToScheme(s) @@ -429,7 +439,7 @@ var _ = Describe("ThinEngine_CheckWorkersReady", func() { }, } - s := runtimeschema.NewScheme() + s := apimachineryruntime.NewScheme() s.AddKnownTypes(datav1alpha1.GroupVersion, runtime, data) s.AddKnownTypes(appsv1.SchemeGroupVersion, fuse, worker) _ = v1.AddToScheme(s) From 1db99120ec71df8f18dfadfd927c64159f0c6600 Mon Sep 17 00:00:00 2001 From: Harsh Date: Wed, 28 Jan 2026 19:48:39 +0530 Subject: [PATCH 3/4] fix: change base suite and tests to package base Signed-off-by: Harsh --- pkg/ddc/base/base_suite_test.go | 2 +- pkg/ddc/base/runtime_conventions_test.go | 5 ++--- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/pkg/ddc/base/base_suite_test.go b/pkg/ddc/base/base_suite_test.go index 641ab093da9..ac01c45c31a 100644 --- a/pkg/ddc/base/base_suite_test.go +++ b/pkg/ddc/base/base_suite_test.go @@ -14,7 +14,7 @@ See the License for the specific language governing permissions and limitations under the License. */ -package base_test +package base import ( "testing" diff --git a/pkg/ddc/base/runtime_conventions_test.go b/pkg/ddc/base/runtime_conventions_test.go index a9c0ccdc63b..7b35255f2b9 100644 --- a/pkg/ddc/base/runtime_conventions_test.go +++ b/pkg/ddc/base/runtime_conventions_test.go @@ -14,11 +14,10 @@ See the License for the specific language governing permissions and limitations under the License. */ -package base_test +package base import ( "github.com/fluid-cloudnative/fluid/pkg/common" - "github.com/fluid-cloudnative/fluid/pkg/ddc/base" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" ) @@ -28,7 +27,7 @@ const testNamespace = "default" var _ = Describe("RuntimeInfo.GetWorkerStatefulsetName", func() { DescribeTable("returns correct statefulset name", func(runtimeName, runtimeType, suffix string) { - info, err := base.BuildRuntimeInfo(runtimeName, testNamespace, runtimeType) + info, err := BuildRuntimeInfo(runtimeName, testNamespace, runtimeType) Expect(err).NotTo(HaveOccurred()) Expect(info.GetWorkerStatefulsetName()).To(Equal(runtimeName + suffix)) }, From 5c26c461ef9a6937da868e2d9f416326cbce1013 Mon Sep 17 00:00:00 2001 From: Harsh Date: Thu, 29 Jan 2026 00:32:57 +0530 Subject: [PATCH 4/4] fix: revert accidental changes to base package Restores pkg/ddc/base/base_suite_test.go and runtime_conventions_test.go to their upstream versions. These files should remain as package base_test (external test package) to avoid conflicts with existing tests. Signed-off-by: Harsh --- pkg/ddc/base/base_suite_test.go | 2 +- pkg/ddc/base/runtime_conventions_test.go | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/pkg/ddc/base/base_suite_test.go b/pkg/ddc/base/base_suite_test.go index ac01c45c31a..641ab093da9 100644 --- a/pkg/ddc/base/base_suite_test.go +++ b/pkg/ddc/base/base_suite_test.go @@ -14,7 +14,7 @@ See the License for the specific language governing permissions and limitations under the License. */ -package base +package base_test import ( "testing" diff --git a/pkg/ddc/base/runtime_conventions_test.go b/pkg/ddc/base/runtime_conventions_test.go index 7b35255f2b9..a9c0ccdc63b 100644 --- a/pkg/ddc/base/runtime_conventions_test.go +++ b/pkg/ddc/base/runtime_conventions_test.go @@ -14,10 +14,11 @@ See the License for the specific language governing permissions and limitations under the License. */ -package base +package base_test import ( "github.com/fluid-cloudnative/fluid/pkg/common" + "github.com/fluid-cloudnative/fluid/pkg/ddc/base" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" ) @@ -27,7 +28,7 @@ const testNamespace = "default" var _ = Describe("RuntimeInfo.GetWorkerStatefulsetName", func() { DescribeTable("returns correct statefulset name", func(runtimeName, runtimeType, suffix string) { - info, err := BuildRuntimeInfo(runtimeName, testNamespace, runtimeType) + info, err := base.BuildRuntimeInfo(runtimeName, testNamespace, runtimeType) Expect(err).NotTo(HaveOccurred()) Expect(info.GetWorkerStatefulsetName()).To(Equal(runtimeName + suffix)) },