This is an automated email from the ASF dual-hosted git repository.
squakez pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel-k.git
The following commit(s) were added to refs/heads/main by this push:
new 973bbd3a5 test(e2e): cover owner trait configuration (#6966)
973bbd3a5 is described below
commit 973bbd3a5faa826ed80bea626ea48de2cebf0cf4
Author: Sanjeev Kumar <[email protected]>
AuthorDate: Fri Nov 20 12:46:51 2026 +0530
test(e2e): cover owner trait configuration (#6966)
* test(e2e): cover owner trait configuration
* test(e2e): simplify owner deployment assertions
* test(e2e): assert Integration owner reference type
* test(e2e): fix owner reference assertions
* test(e2e): fix owner annotation propagation coverage
* test(e2e): scope owner assertions to subtests
* test(e2e): scope owner assertions to each subtest
* test(e2e): use medium timeout for owner annotation test
* test(e2e): assert preserved pod template annotation
* test(e2e): wait for owner deployment before assertions
* test(e2e): use custom owner annotation keys
* test(e2e): verify owner annotation filtering on Service
---
e2e/common/traits/owner_test.go | 150 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 150 insertions(+)
diff --git a/e2e/common/traits/owner_test.go b/e2e/common/traits/owner_test.go
new file mode 100644
index 000000000..9be9588ae
--- /dev/null
+++ b/e2e/common/traits/owner_test.go
@@ -0,0 +1,150 @@
+//go:build integration
+// +build integration
+
+// To enable compilation of this file in Goland, go to "Settings -> Go ->
Vendoring & Build Tags -> Custom Tags" and add "integration"
+
+/*
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements. See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You 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 common
+
+import (
+ "context"
+ "testing"
+
+ . "github.com/onsi/gomega"
+
+ corev1 "k8s.io/api/core/v1"
+
+ . "github.com/apache/camel-k/v2/e2e/support"
+ v1 "github.com/apache/camel-k/v2/pkg/apis/camel/v1"
+)
+
+func TestOwnerTrait(t *testing.T) {
+ t.Parallel()
+
+ WithNewTestNamespace(t, func(ctx context.Context, _ *WithT, ns string) {
+ t.Run("selected labels and annotations are propagated to owned
resources", func(t *testing.T) {
+ g := NewWithT(t)
+ name := RandomizedSuffixName("owner-selected")
+ selectedLabel := "owner-test-selected-label"
+ unselectedLabel := "owner-test-unselected-label"
+ selectedAnnotation :=
"owner-test.camel.apache.org/selected"
+ unselectedAnnotation :=
"owner-test.camel.apache.org/unselected"
+
+ g.Expect(KamelRun(t, ctx, ns,
"files/PlatformHttpServer.java",
+ "--name", name,
+ "--label", selectedLabel+"=selected",
+ "--label", unselectedLabel+"=unselected",
+ "--annotation", selectedAnnotation+"=selected",
+ "--annotation",
unselectedAnnotation+"=unselected",
+ "-t", "owner.target-labels="+selectedLabel,
+ "-t",
"owner.target-annotations="+selectedAnnotation,
+ ).Execute()).To(Succeed())
+
+ g.Eventually(IntegrationConditionStatus(t, ctx, ns,
name, v1.IntegrationConditionReady), TestTimeoutMedium).
+ Should(Equal(corev1.ConditionTrue))
+
+ integration := Integration(t, ctx, ns, name)()
+ g.Expect(integration).NotTo(BeNil())
+ g.Eventually(Deployment(t, ctx, ns, name),
TestTimeoutMedium).ShouldNot(BeNil())
+
+ deployment := Deployment(t, ctx, ns, name)()
+ g.Expect(deployment).NotTo(BeNil())
+
g.Expect(deployment.Labels).To(HaveKeyWithValue(selectedLabel, "selected"))
+
g.Expect(deployment.Labels).NotTo(HaveKey(unselectedLabel))
+
g.Expect(deployment.Spec.Template.Labels).To(HaveKeyWithValue(selectedLabel,
"selected"))
+
g.Expect(deployment.Spec.Template.Labels).NotTo(HaveKey(unselectedLabel))
+
+
g.Expect(deployment.Annotations).To(HaveKeyWithValue(selectedAnnotation,
"selected"))
+
g.Expect(deployment.Spec.Template.Annotations).To(HaveKeyWithValue(selectedAnnotation,
"selected"))
+
+ // The Deployment trait copies transferable Integration
annotations before
+ // the Owner trait runs. Check filtering on the
Service, which starts with
+ // only Service-trait annotations.
+ g.Eventually(Service(t, ctx, ns, name),
TestTimeoutMedium).ShouldNot(BeNil())
+ service := Service(t, ctx, ns, name)()
+
g.Expect(service.Annotations).To(HaveKeyWithValue(selectedAnnotation,
"selected"))
+
g.Expect(service.Annotations).NotTo(HaveKey(unselectedAnnotation))
+
+ g.Expect(deployment.OwnerReferences).To(HaveLen(1))
+ ownerReference := deployment.OwnerReferences[0]
+
g.Expect(ownerReference.APIVersion).To(Equal(v1.SchemeGroupVersion.String()))
+ g.Expect(ownerReference.Kind).To(Equal("Integration"))
+
g.Expect(ownerReference.Name).To(Equal(integration.Name))
+ g.Expect(ownerReference.UID).To(Equal(integration.UID))
+ g.Expect(ownerReference.Controller).NotTo(BeNil())
+ g.Expect(*ownerReference.Controller).To(BeTrue())
+
g.Expect(ownerReference.BlockOwnerDeletion).NotTo(BeNil())
+
g.Expect(*ownerReference.BlockOwnerDeletion).To(BeTrue())
+ })
+
+ t.Run("existing Pod template annotation is not overwritten",
func(t *testing.T) {
+ g := NewWithT(t)
+ name :=
RandomizedSuffixName("owner-annotation-conflict")
+ defaultContainerAnnotation :=
"kubectl.kubernetes.io/default-container"
+
+ g.Expect(KamelRun(t, ctx, ns,
"files/PlatformHttpServer.java",
+ "--name", name,
+ "--annotation",
defaultContainerAnnotation+"=must-not-overwrite",
+ "-t",
"owner.target-annotations="+defaultContainerAnnotation,
+ ).Execute()).To(Succeed())
+
+ g.Eventually(IntegrationConditionStatus(t, ctx, ns,
name, v1.IntegrationConditionReady), TestTimeoutMedium).
+ Should(Equal(corev1.ConditionTrue))
+ g.Eventually(Deployment(t, ctx, ns, name),
TestTimeoutMedium).ShouldNot(BeNil())
+
+ deployment := Deployment(t, ctx, ns, name)()
+
g.Expect(deployment.Spec.Template.Annotations).To(HaveKeyWithValue(defaultContainerAnnotation,
"integration"))
+ })
+
+ t.Run("wildcard propagates all labels and annotations", func(t
*testing.T) {
+ g := NewWithT(t)
+ name := RandomizedSuffixName("owner-wildcard")
+ labelOne := "owner-test-wildcard-one"
+ labelTwo := "owner-test-wildcard-two"
+ annotationOne :=
"owner-test.camel.apache.org/wildcard-one"
+ annotationTwo :=
"owner-test.camel.apache.org/wildcard-two"
+
+ g.Expect(KamelRun(t, ctx, ns,
"files/PlatformHttpServer.java",
+ "--name", name,
+ "--label", labelOne+"=one",
+ "--label", labelTwo+"=two",
+ "--annotation", annotationOne+"=one",
+ "--annotation", annotationTwo+"=two",
+ "-t", "owner.target-labels=*",
+ "-t", "owner.target-annotations=*",
+ ).Execute()).To(Succeed())
+
+ g.Eventually(IntegrationConditionStatus(t, ctx, ns,
name, v1.IntegrationConditionReady), TestTimeoutMedium).
+ Should(Equal(corev1.ConditionTrue))
+ g.Eventually(Deployment(t, ctx, ns, name),
TestTimeoutMedium).ShouldNot(BeNil())
+
+ deployment := Deployment(t, ctx, ns, name)()
+
g.Expect(deployment.Labels).To(HaveKeyWithValue(labelOne, "one"))
+
g.Expect(deployment.Labels).To(HaveKeyWithValue(labelTwo, "two"))
+
g.Expect(deployment.Spec.Template.Labels).To(HaveKeyWithValue(labelOne, "one"))
+
g.Expect(deployment.Spec.Template.Labels).To(HaveKeyWithValue(labelTwo, "two"))
+
g.Expect(deployment.Annotations).To(HaveKeyWithValue(annotationOne, "one"))
+
g.Expect(deployment.Annotations).To(HaveKeyWithValue(annotationTwo, "two"))
+
g.Expect(deployment.Spec.Template.Annotations).To(HaveKeyWithValue(annotationOne,
"one"))
+
g.Expect(deployment.Spec.Template.Annotations).To(HaveKeyWithValue(annotationTwo,
"two"))
+ g.Expect(deployment.OwnerReferences).To(HaveLen(1))
+ })
+
+ })
+}