fix: unit test not stable

parallel/task_test.go

@@ -191,7 +191,7 @@ var _ = Describe("P().Do().Wait()", func() {
 			// Expect(t2Excuted.executed).To(BeFalse())
 			// Expect(t3Excuted.executed).To(BeFalse())
 
-			Expect(elapsed < 1 && elapsed > 0.1).To(BeTrue())
+			Expect(elapsed > 0.1 && elapsed < 5).To(BeTrue(), fmt.Sprintf("actual elapsed: %v", elapsed))
 			Expect(len(res)).To(BeEquivalentTo(0))
 		})
 	})

testing/convert.go

@@ -19,7 +19,10 @@ package testing
 import (
 	"fmt"
 
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
@@ -32,3 +35,34 @@ func DefaultConvertRuntimeToClientobjectFunc(runtimeObj runtime.Object) (obj cli
 	}
 	return
 }
+
+// ConvertTypeMetaToGroupVersionResource converts type meta to group version resource
+func ConvertTypeMetaToGroupVersionResource(typeMeta metav1.TypeMeta) schema.GroupVersionResource {
+	gv, _ := schema.ParseGroupVersion(typeMeta.APIVersion)
+	gvk := gv.WithKind(typeMeta.Kind)
+	plural, _ := meta.UnsafeGuessKindToResource(gvk)
+	return plural
+}
+
+// SliceToRuntimeOjbect convert slice to runtime.Object
+func SliceToRuntimeOjbect[T any](s []T) []runtime.Object {
+	r := make([]runtime.Object, 0, len(s))
+	for _, v := range s {
+		if o, ok := any(v).(runtime.Object); ok {
+			r = append(r, o)
+		}
+	}
+	if len(r) == 0 {
+		return nil
+	}
+	return r
+}
+
+// SliceToInterfaceSlice convert a slice to a slice of interface
+func SliceToInterfaceSlice[T any](s []T) []interface{} {
+	r := make([]interface{}, len(s))
+	for i, v := range s {
+		r[i] = v
+	}
+	return r
+}

testing/convert_test.go

@@ -0,0 +1,138 @@
+/*
+Copyright 2024 The Katanomi Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package testing
+
+import (
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+var _ = Describe("Test.ConvertTypeMetaToGroupVersionResource", func() {
+	DescribeTable("Converts TypeMeta to GroupVersionResource",
+		func(apiVersion, kind string, expectedGVR schema.GroupVersionResource) {
+			typeMeta := metav1.TypeMeta{
+				APIVersion: apiVersion,
+				Kind:       kind,
+			}
+			Expect(ConvertTypeMetaToGroupVersionResource(typeMeta)).To(Equal(expectedGVR))
+		},
+		Entry("should handle normal resources",
+			"batch/v1", "Job", schema.GroupVersionResource{
+				Group:    "batch",
+				Version:  "v1",
+				Resource: "jobs",
+			}),
+		Entry("should handle namespaced API group",
+			"tekton.dev/v1beta1", "Task", schema.GroupVersionResource{
+				Group:    "tekton.dev",
+				Version:  "v1beta1",
+				Resource: "tasks",
+			}),
+		Entry("should handle core API group",
+			"v1", "Pod", schema.GroupVersionResource{
+				Group:    "",
+				Version:  "v1",
+				Resource: "pods",
+			}),
+		Entry("should handle special resources",
+			"group/version", "Jenkins", schema.GroupVersionResource{
+				Group:    "group",
+				Version:  "version",
+				Resource: "jenkinses",
+			}),
+		Entry("should handle special resources",
+			"group/version", "Policy", schema.GroupVersionResource{
+				Group:    "group",
+				Version:  "version",
+				Resource: "policies",
+			}),
+	)
+})
+
+var _ = Describe("Test.SliceToInterfaceSlice", func() {
+	Context("with different slice types", func() {
+		It("should convert empty slice", func() {
+			input := []string{}
+			expected := []interface{}{}
+			result := SliceToInterfaceSlice[string](input)
+			Expect(result).To(Equal(expected))
+		})
+
+		It("should convert slice of int", func() {
+			input := []int{1, 2, 3}
+			expected := []interface{}{1, 2, 3}
+			result := SliceToInterfaceSlice[int](input)
+			Expect(result).To(Equal(expected))
+		})
+
+		It("should convert slice of float", func() {
+			input := []float64{1.1, 2.2, 3.3}
+			expected := []interface{}{1.1, 2.2, 3.3}
+			result := SliceToInterfaceSlice[float64](input)
+			Expect(result).To(Equal(expected))
+		})
+
+		It("should convert slice of string", func() {
+			input := []string{"a", "b", "c"}
+			expected := []interface{}{"a", "b", "c"}
+			result := SliceToInterfaceSlice[string](input)
+			Expect(result).To(Equal(expected))
+		})
+	})
+})
+
+var _ = Describe("Test.SliceToRuntimeOjbect", func() {
+	Context("when given a slice of any type", func() {
+		It("should convert the slice to runtime.Object", func() {
+			// Test case 1: Empty slice
+			Expect(SliceToRuntimeOjbect[int]([]int{})).To(BeEmpty())
+
+			// Test case 2: All elements can be converted to runtime.Object
+			Expect(SliceToRuntimeOjbect[interface{}]([]interface{}{
+				&corev1.Pod{},
+				&corev1.Pod{},
+				&corev1.Pod{},
+			})).To(Equal([]runtime.Object{
+				&corev1.Pod{},
+				&corev1.Pod{},
+				&corev1.Pod{},
+			}))
+
+			// Test case 3: Some elements can be converted to runtime.Object
+			Expect(SliceToRuntimeOjbect([]interface{}{
+				&corev1.Pod{},
+				false,
+				&corev1.Pod{},
+			})).To(Equal([]runtime.Object{
+				&corev1.Pod{},
+				&corev1.Pod{},
+			}))
+
+			// Test case 4: No element can be converted to runtime.Object
+			Expect(SliceToRuntimeOjbect([]interface{}{
+				42,
+				false,
+				"string",
+			})).To(BeEmpty())
+		})
+	})
+})

testing/testing_suite_test.go

@@ -21,9 +21,12 @@ import (
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
+	"github.com/onsi/gomega/format"
 )
 
 func TestTesting(t *testing.T) {
+	format.MaxLength = 0
+
 	RegisterFailHandler(Fail)
 	RunSpecs(t, "Testing Suite")
 }