Merge pull request #115 from triggermesh/task/add-semantic-compare-jobs

Add semantic compare jobs

Author: Pablo Mercado

pkg/reconciler/semantic/semantic.go

@@ -5,6 +5,7 @@ package semantic
 
 import (
 	appsv1 "k8s.io/api/apps/v1"
+	batchv1 "k8s.io/api/batch/v1"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -24,6 +25,7 @@ var Semantic = conversion.EqualitiesOrDie(
 	serviceAccountEqual,
 	serviceEqual,
 	secretEqual,
+	jobEqual,
 )
 
 // eq is an instance of Equalities for internal deep derivative comparisons
@@ -171,3 +173,22 @@ func serviceAccountEqual(a, b *corev1.ServiceAccount) bool {
 
 	return true
 }
+
+func jobEqual(a, b *batchv1.Job) bool {
+	if a == b {
+		return true
+	}
+	if a == nil || b == nil {
+		return false
+	}
+
+	if !eq.DeepDerivative(&a.ObjectMeta, &b.ObjectMeta) {
+		return false
+	}
+
+	if !eq.DeepDerivative(&a.Spec, &b.Spec) {
+		return false
+	}
+
+	return true
+}

pkg/reconciler/semantic/semantic_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	appsv1 "k8s.io/api/apps/v1"
+	batchv1 "k8s.io/api/batch/v1"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 )
@@ -221,6 +222,104 @@ const (
         "updatedReplicas": 1
     }
 }
+`
+
+	tJob = `
+{
+	"apiVersion": "batch/v1",
+	"kind": "Job",
+	"metadata": {
+		"annotations": {
+			"batch.kubernetes.io/job-tracking": ""
+		},
+		"creationTimestamp": "2023-04-12T08:32:12Z",
+		"generation": 1,
+		"labels": {
+			"app.kubernetes.io/managed-by": "triggermesh-core",
+			"app.kubernetes.io/part-of": "triggermesh",
+			"controller-uid": "dad9425a-3410-40ea-832e-31b087f8f808",
+			"job-name": "test"
+		},
+		"name": "test",
+		"namespace": "default",
+		"resourceVersion": "650907",
+		"uid": "dad9425a-3410-40ea-832e-31b087f8f808"
+	},
+	"spec": {
+		"backoffLimit": 3,
+		"completionMode": "NonIndexed",
+		"completions": 1,
+		"parallelism": 1,
+		"selector": {
+			"matchLabels": {
+				"controller-uid": "dad9425a-3410-40ea-832e-31b087f8f808"
+			}
+		},
+		"suspend": false,
+		"template": {
+			"metadata": {
+				"creationTimestamp": null,
+				"labels": {
+					"app.kubernetes.io/managed-by": "triggermesh-core",
+					"app.kubernetes.io/part-of": "triggermesh",
+					"controller-uid": "dad9425a-3410-40ea-832e-31b087f8f808",
+					"job-name": "test"
+				},
+				"ownerReferences": [
+					{
+						"apiVersion": "eventing.triggermesh.io/v1alpha1",
+						"kind": "TestKind",
+						"name": "test",
+						"uid": "186f3c1b-952b-4e45-9837-2ee6bd4436ec"
+					}
+				]
+			},
+			"spec": {
+				"containers": [
+					{
+						"env": [
+                            {
+                                "name": "ENV_ONE",
+                                "value": "1"
+                            },
+                            {
+                                "name": "ENV_TWO",
+                                "value": "2"
+                            }
+						],
+						"image": "test/test:latest",
+						"imagePullPolicy": "Always",
+						"name": "test",
+						"resources": {},
+						"terminationMessagePath": "/dev/termination-log",
+						"terminationMessagePolicy": "File"
+					}
+				],
+				"dnsPolicy": "ClusterFirst",
+				"restartPolicy": "Never",
+				"schedulerName": "default-scheduler",
+				"securityContext": {},
+				"terminationGracePeriodSeconds": 30
+			}
+		}
+	},
+	"status": {
+		"conditions": [
+			{
+				"lastProbeTime": "2023-04-12T08:34:02Z",
+				"lastTransitionTime": "2023-04-12T08:34:02Z",
+				"message": "Job has reached the specified backoff limit",
+				"reason": "BackoffLimitExceeded",
+				"status": "True",
+				"type": "Failed"
+			}
+		],
+		"failed": 1,
+		"ready": 0,
+		"startTime": "2023-04-12T08:32:12Z",
+		"uncountedTerminatedPods": {}
+	}
+}
 `
 )
 
@@ -404,3 +503,90 @@ func loadFixture(t *testing.T, contents string, obj runtime.Object) {
 		t.Fatalf("Error deserializing fixture object: %s", err)
 	}
 }
+
+func TestJobEqual(t *testing.T) {
+	current := &batchv1.Job{}
+	loadFixture(t, tJob, current)
+
+	require.GreaterOrEqual(t, len(current.Labels), 2,
+		"Test suite requires a reference object with at least 2 labels to run properly")
+	require.True(t, len(current.Spec.Template.Spec.Containers) > 0 &&
+		len(current.Spec.Template.Spec.Containers[0].Env) > 0 &&
+		current.Spec.Template.Spec.Containers[0].Env[0].Value != "",
+		"Test suite requires a reference object with a Container that has at least 1 EnvVar to run properly")
+
+	assert.True(t, deploymentEqual(nil, nil), "Two nil elements should be equal")
+
+	testCases := map[string]struct {
+		prep   func() *batchv1.Job
+		expect bool
+	}{
+		"not equal when one element is nil": {
+			func() *batchv1.Job {
+				return nil
+			},
+			false,
+		},
+		// counter intuitive but expected result for deep derivative comparisons
+		"equal when all desired attributes are empty": {
+			func() *batchv1.Job {
+				return &batchv1.Job{}
+			},
+			true,
+		},
+		"not equal when some existing attribute differs": {
+			func() *batchv1.Job {
+				desired := current.DeepCopy()
+				for k := range desired.Labels {
+					desired.Labels[k] += "test"
+					break // changing one is enough
+				}
+				return desired
+			},
+			false,
+		},
+		"equal when current has more attributes than desired": {
+			func() *batchv1.Job {
+				desired := current.DeepCopy()
+				for k := range desired.Labels {
+					delete(desired.Labels, k)
+					break // deleting one is enough
+				}
+				return desired
+			},
+			true,
+		},
+		"not equal when desired has more attributes than current": {
+			func() *batchv1.Job {
+				desired := current.DeepCopy()
+				for k := range desired.Labels {
+					desired.Labels[k+"test"] = "test"
+					break // adding one is enough
+				}
+				return desired
+			},
+			false,
+		},
+		"not equal when EnvVar desired value is empty": {
+			func() *batchv1.Job {
+				desired := current.DeepCopy()
+				desired.Spec.Template.Spec.Containers[0].Env[0].Value = ""
+				return desired
+			},
+			false,
+		},
+	}
+
+	for name, tc := range testCases {
+		//nolint:scopelint
+		t.Run(name, func(t *testing.T) {
+			desired := tc.prep()
+			switch tc.expect {
+			case true:
+				assert.True(t, jobEqual(desired, current))
+			case false:
+				assert.False(t, jobEqual(desired, current))
+			}
+		})
+	}
+}