Merge branch 'master' into fix/specific-namespace

internal/pkg/alerts/alert.go

@@ -35,6 +35,8 @@ func SendWebhookAlert(msg string) {
 		sendSlackAlert(webhook_url, webhook_proxy, msg)
 	} else if alert_sink == "teams" {
 		sendTeamsAlert(webhook_url, webhook_proxy, msg)
+	} else if alert_sink == "gchat" {
+		sendGoogleChatAlert(webhook_url, webhook_proxy, msg)
 	} else {
 		msg = strings.Replace(msg, "*", "", -1)
 		sendRawWebhookAlert(webhook_url, webhook_proxy, msg)
@@ -98,6 +100,29 @@ func sendTeamsAlert(webhookUrl string, proxy string, msg string) []error {
 	return nil
 }
 
+// function to send alert to Google Chat webhook
+func sendGoogleChatAlert(webhookUrl string, proxy string, msg string) []error {
+	payload := map[string]interface{}{
+		"text": msg,
+	}
+
+	request := gorequest.New().Proxy(proxy)
+	resp, _, err := request.
+		Post(webhookUrl).
+		RedirectPolicy(redirectPolicy).
+		Send(payload).
+		End()
+
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode != 200 {
+		return []error{fmt.Errorf("error sending msg. status: %v", resp.Status)}
+	}
+
+	return nil
+}
+
 // function to send alert to webhook service as text
 func sendRawWebhookAlert(webhookUrl string, proxy string, msg string) []error {
 	request := gorequest.New().Proxy(proxy)

internal/pkg/callbacks/rolling_upgrade.go

@@ -17,7 +17,6 @@ import (
 	patchtypes "k8s.io/apimachinery/pkg/types"
 
 	argorolloutv1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1"
-	openshiftv1 "github.com/openshift/api/apps/v1"
 )
 
 // ItemFunc is a generic function to return a specific resource in given namespace
@@ -232,36 +231,6 @@ func GetStatefulSetItems(clients kube.Clients, namespace string) []runtime.Objec
 	return items
 }
 
-// GetDeploymentConfigItem returns the deploymentConfig in given namespace
-func GetDeploymentConfigItem(clients kube.Clients, name string, namespace string) (runtime.Object, error) {
-	deploymentConfig, err := clients.OpenshiftAppsClient.AppsV1().DeploymentConfigs(namespace).Get(context.TODO(), name, meta_v1.GetOptions{})
-	if err != nil {
-		logrus.Errorf("Failed to get deploymentConfig %v", err)
-		return nil, err
-	}
-
-	return deploymentConfig, nil
-}
-
-// GetDeploymentConfigItems returns the deploymentConfigs in given namespace
-func GetDeploymentConfigItems(clients kube.Clients, namespace string) []runtime.Object {
-	deploymentConfigs, err := clients.OpenshiftAppsClient.AppsV1().DeploymentConfigs(namespace).List(context.TODO(), meta_v1.ListOptions{})
-	if err != nil {
-		logrus.Errorf("Failed to list deploymentConfigs %v", err)
-	}
-
-	items := make([]runtime.Object, len(deploymentConfigs.Items))
-	// Ensure we always have pod annotations to add to
-	for i, v := range deploymentConfigs.Items {
-		if v.Spec.Template.ObjectMeta.Annotations == nil {
-			deploymentConfigs.Items[i].Spec.Template.ObjectMeta.Annotations = make(map[string]string)
-		}
-		items[i] = &deploymentConfigs.Items[i]
-	}
-
-	return items
-}
-
 // GetRolloutItem returns the rollout in given namespace
 func GetRolloutItem(clients kube.Clients, name string, namespace string) (runtime.Object, error) {
 	rollout, err := clients.ArgoRolloutClient.ArgoprojV1alpha1().Rollouts(namespace).Get(context.TODO(), name, meta_v1.GetOptions{})
@@ -332,14 +301,6 @@ func GetStatefulSetAnnotations(item runtime.Object) map[string]string {
 	return item.(*appsv1.StatefulSet).ObjectMeta.Annotations
 }
 
-// GetDeploymentConfigAnnotations returns the annotations of given deploymentConfig
-func GetDeploymentConfigAnnotations(item runtime.Object) map[string]string {
-	if item.(*openshiftv1.DeploymentConfig).ObjectMeta.Annotations == nil {
-		item.(*openshiftv1.DeploymentConfig).ObjectMeta.Annotations = make(map[string]string)
-	}
-	return item.(*openshiftv1.DeploymentConfig).ObjectMeta.Annotations
-}
-
 // GetRolloutAnnotations returns the annotations of given rollout
 func GetRolloutAnnotations(item runtime.Object) map[string]string {
 	if item.(*argorolloutv1alpha1.Rollout).ObjectMeta.Annotations == nil {
@@ -388,14 +349,6 @@ func GetStatefulSetPodAnnotations(item runtime.Object) map[string]string {
 	return item.(*appsv1.StatefulSet).Spec.Template.ObjectMeta.Annotations
 }
 
-// GetDeploymentConfigPodAnnotations returns the pod's annotations of given deploymentConfig
-func GetDeploymentConfigPodAnnotations(item runtime.Object) map[string]string {
-	if item.(*openshiftv1.DeploymentConfig).Spec.Template.ObjectMeta.Annotations == nil {
-		item.(*openshiftv1.DeploymentConfig).Spec.Template.ObjectMeta.Annotations = make(map[string]string)
-	}
-	return item.(*openshiftv1.DeploymentConfig).Spec.Template.ObjectMeta.Annotations
-}
-
 // GetRolloutPodAnnotations returns the pod's annotations of given rollout
 func GetRolloutPodAnnotations(item runtime.Object) map[string]string {
 	if item.(*argorolloutv1alpha1.Rollout).Spec.Template.ObjectMeta.Annotations == nil {
@@ -429,11 +382,6 @@ func GetStatefulSetContainers(item runtime.Object) []v1.Container {
 	return item.(*appsv1.StatefulSet).Spec.Template.Spec.Containers
 }
 
-// GetDeploymentConfigContainers returns the containers of given deploymentConfig
-func GetDeploymentConfigContainers(item runtime.Object) []v1.Container {
-	return item.(*openshiftv1.DeploymentConfig).Spec.Template.Spec.Containers
-}
-
 // GetRolloutContainers returns the containers of given rollout
 func GetRolloutContainers(item runtime.Object) []v1.Container {
 	return item.(*argorolloutv1alpha1.Rollout).Spec.Template.Spec.Containers
@@ -464,11 +412,6 @@ func GetStatefulSetInitContainers(item runtime.Object) []v1.Container {
 	return item.(*appsv1.StatefulSet).Spec.Template.Spec.InitContainers
 }
 
-// GetDeploymentConfigInitContainers returns the containers of given deploymentConfig
-func GetDeploymentConfigInitContainers(item runtime.Object) []v1.Container {
-	return item.(*openshiftv1.DeploymentConfig).Spec.Template.Spec.InitContainers
-}
-
 // GetRolloutInitContainers returns the containers of given rollout
 func GetRolloutInitContainers(item runtime.Object) []v1.Container {
 	return item.(*argorolloutv1alpha1.Rollout).Spec.Template.Spec.InitContainers
@@ -575,19 +518,6 @@ func PatchStatefulSet(clients kube.Clients, namespace string, resource runtime.O
 	return err
 }
 
-// UpdateDeploymentConfig performs rolling upgrade on deploymentConfig
-func UpdateDeploymentConfig(clients kube.Clients, namespace string, resource runtime.Object) error {
-	deploymentConfig := resource.(*openshiftv1.DeploymentConfig)
-	_, err := clients.OpenshiftAppsClient.AppsV1().DeploymentConfigs(namespace).Update(context.TODO(), deploymentConfig, meta_v1.UpdateOptions{FieldManager: "Reloader"})
-	return err
-}
-
-func PatchDeploymentConfig(clients kube.Clients, namespace string, resource runtime.Object, patchType patchtypes.PatchType, bytes []byte) error {
-	deploymentConfig := resource.(*openshiftv1.DeploymentConfig)
-	_, err := clients.OpenshiftAppsClient.AppsV1().DeploymentConfigs(namespace).Patch(context.TODO(), deploymentConfig.Name, patchType, bytes, meta_v1.PatchOptions{FieldManager: "Reloader"})
-	return err
-}
-
 // UpdateRollout performs rolling upgrade on rollout
 func UpdateRollout(clients kube.Clients, namespace string, resource runtime.Object) error {
 	rollout := resource.(*argorolloutv1alpha1.Rollout)
@@ -631,11 +561,6 @@ func GetStatefulSetVolumes(item runtime.Object) []v1.Volume {
 	return item.(*appsv1.StatefulSet).Spec.Template.Spec.Volumes
 }
 
-// GetDeploymentConfigVolumes returns the Volumes of given deploymentConfig
-func GetDeploymentConfigVolumes(item runtime.Object) []v1.Volume {
-	return item.(*openshiftv1.DeploymentConfig).Spec.Template.Spec.Volumes
-}
-
 // GetRolloutVolumes returns the Volumes of given rollout
 func GetRolloutVolumes(item runtime.Object) []v1.Volume {
 	return item.(*argorolloutv1alpha1.Rollout).Spec.Template.Spec.Volumes

internal/pkg/controller/controller_test.go

@@ -68,64 +68,6 @@ func TestMain(m *testing.M) {
 	os.Exit(retCode)
 }
 
-// Perform rolling upgrade on deploymentConfig and create pod annotation var upon updating the configmap
-func TestControllerUpdatingConfigmapShouldCreatePodAnnotationInDeploymentConfig(t *testing.T) {
-	options.ReloadStrategy = constants.AnnotationsReloadStrategy
-
-	// Don't run test on non-openshift environment
-	if !kube.IsOpenshift {
-		return
-	}
-
-	// Creating configmap
-	configmapName := configmapNamePrefix + "-update-" + testutil.RandSeq(5)
-	configmapClient, err := testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapName, "www.google.com")
-	if err != nil {
-		t.Errorf("Error while creating the configmap %v", err)
-	}
-
-	// Creating deployment
-	_, err = testutil.CreateDeploymentConfig(clients.OpenshiftAppsClient, configmapName, namespace, true)
-	if err != nil {
-		t.Errorf("Error in deploymentConfig creation: %v", err)
-	}
-
-	// Updating configmap for first time
-	updateErr := testutil.UpdateConfigMap(configmapClient, namespace, configmapName, "", "www.stakater.com")
-	if updateErr != nil {
-		t.Errorf("Configmap was not updated")
-	}
-
-	// Verifying deployment update
-	logrus.Infof("Verifying pod annotation has been created")
-	shaData := testutil.ConvertResourceToSHA(testutil.ConfigmapResourceType, namespace, configmapName, "www.stakater.com")
-	config := util.Config{
-		Namespace:    namespace,
-		ResourceName: configmapName,
-		SHAValue:     shaData,
-		Annotation:   options.ConfigmapUpdateOnChangeAnnotation,
-	}
-	deploymentConfigFuncs := handler.GetDeploymentConfigRollingUpgradeFuncs()
-	updated := testutil.VerifyResourceAnnotationUpdate(clients, config, deploymentConfigFuncs)
-	if !updated {
-		t.Errorf("DeploymentConfig was not updated")
-	}
-	time.Sleep(sleepDuration)
-
-	// Deleting deployment
-	err = testutil.DeleteDeploymentConfig(clients.OpenshiftAppsClient, namespace, configmapName)
-	if err != nil {
-		logrus.Errorf("Error while deleting the deploymentConfig %v", err)
-	}
-
-	// Deleting configmap
-	err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapName)
-	if err != nil {
-		logrus.Errorf("Error while deleting the configmap %v", err)
-	}
-	time.Sleep(sleepDuration)
-}
-
 // Perform rolling upgrade on deployment and create pod annotation var upon updating the configmap
 func TestControllerUpdatingConfigmapShouldCreatePodAnnotationInDeployment(t *testing.T) {
 	options.ReloadStrategy = constants.AnnotationsReloadStrategy
@@ -1078,64 +1020,6 @@ func TestControllerUpdatingSecretShouldCreatePodAnnotationInStatefulSet(t *testi
 	time.Sleep(sleepDuration)
 }
 
-// Perform rolling upgrade on deploymentConfig and create env var upon updating the configmap
-func TestControllerUpdatingConfigmapShouldCreateEnvInDeploymentConfig(t *testing.T) {
-	options.ReloadStrategy = constants.EnvVarsReloadStrategy
-
-	// Don't run test on non-openshift environment
-	if !kube.IsOpenshift {
-		return
-	}
-
-	// Creating configmap
-	configmapName := configmapNamePrefix + "-update-" + testutil.RandSeq(5)
-	configmapClient, err := testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapName, "www.google.com")
-	if err != nil {
-		t.Errorf("Error while creating the configmap %v", err)
-	}
-
-	// Creating deployment
-	_, err = testutil.CreateDeploymentConfig(clients.OpenshiftAppsClient, configmapName, namespace, true)
-	if err != nil {
-		t.Errorf("Error in deploymentConfig creation: %v", err)
-	}
-
-	// Updating configmap for first time
-	updateErr := testutil.UpdateConfigMap(configmapClient, namespace, configmapName, "", "www.stakater.com")
-	if updateErr != nil {
-		t.Errorf("Configmap was not updated")
-	}
-
-	// Verifying deployment update
-	logrus.Infof("Verifying env var has been created")
-	shaData := testutil.ConvertResourceToSHA(testutil.ConfigmapResourceType, namespace, configmapName, "www.stakater.com")
-	config := util.Config{
-		Namespace:    namespace,
-		ResourceName: configmapName,
-		SHAValue:     shaData,
-		Annotation:   options.ConfigmapUpdateOnChangeAnnotation,
-	}
-	deploymentConfigFuncs := handler.GetDeploymentConfigRollingUpgradeFuncs()
-	updated := testutil.VerifyResourceEnvVarUpdate(clients, config, constants.ConfigmapEnvVarPostfix, deploymentConfigFuncs)
-	if !updated {
-		t.Errorf("DeploymentConfig was not updated")
-	}
-	time.Sleep(sleepDuration)
-
-	// Deleting deployment
-	err = testutil.DeleteDeploymentConfig(clients.OpenshiftAppsClient, namespace, configmapName)
-	if err != nil {
-		logrus.Errorf("Error while deleting the deploymentConfig %v", err)
-	}
-
-	// Deleting configmap
-	err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapName)
-	if err != nil {
-		logrus.Errorf("Error while deleting the configmap %v", err)
-	}
-	time.Sleep(sleepDuration)
-}
-
 // Perform rolling upgrade on deployment and create env var upon updating the configmap
 func TestControllerUpdatingConfigmapShouldCreateEnvInDeployment(t *testing.T) {
 	options.ReloadStrategy = constants.EnvVarsReloadStrategy

internal/pkg/handler/upgrade.go

@@ -22,9 +22,11 @@ import (
 	"github.com/stakater/Reloader/internal/pkg/util"
 	"github.com/stakater/Reloader/pkg/kube"
 	v1 "k8s.io/api/core/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime"
 	patchtypes "k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/client-go/tools/record"
 	"k8s.io/client-go/util/retry"
 )
@@ -119,24 +121,6 @@ func GetStatefulSetRollingUpgradeFuncs() callbacks.RollingUpgradeFuncs {
 	}
 }
 
-// GetDeploymentConfigRollingUpgradeFuncs returns all callback funcs for a deploymentConfig
-func GetDeploymentConfigRollingUpgradeFuncs() callbacks.RollingUpgradeFuncs {
-	return callbacks.RollingUpgradeFuncs{
-		ItemFunc:           callbacks.GetDeploymentConfigItem,
-		ItemsFunc:          callbacks.GetDeploymentConfigItems,
-		AnnotationsFunc:    callbacks.GetDeploymentConfigAnnotations,
-		PodAnnotationsFunc: callbacks.GetDeploymentConfigPodAnnotations,
-		ContainersFunc:     callbacks.GetDeploymentConfigContainers,
-		InitContainersFunc: callbacks.GetDeploymentConfigInitContainers,
-		UpdateFunc:         callbacks.UpdateDeploymentConfig,
-		PatchFunc:          callbacks.PatchDeploymentConfig,
-		PatchTemplatesFunc: callbacks.GetPatchTemplates,
-		VolumesFunc:        callbacks.GetDeploymentConfigVolumes,
-		ResourceType:       "DeploymentConfig",
-		SupportsPatch:      true,
-	}
-}
-
 // GetArgoRolloutRollingUpgradeFuncs returns all callback funcs for a rollout
 func GetArgoRolloutRollingUpgradeFuncs() callbacks.RollingUpgradeFuncs {
 	return callbacks.RollingUpgradeFuncs{
@@ -210,13 +194,6 @@ func doRollingUpgrade(config util.Config, collectors metrics.Collectors, recorde
 		return err
 	}
 
-	if kube.IsOpenshift {
-		err = rollingUpgrade(clients, config, GetDeploymentConfigRollingUpgradeFuncs(), collectors, recorder, invoke)
-		if err != nil {
-			return err
-		}
-	}
-
 	if options.IsArgoRollouts == "true" {
 		err = rollingUpgrade(clients, config, GetArgoRolloutRollingUpgradeFuncs(), collectors, recorder, invoke)
 		if err != nil {
@@ -228,7 +205,6 @@ func doRollingUpgrade(config util.Config, collectors metrics.Collectors, recorde
 }
 
 func rollingUpgrade(clients kube.Clients, config util.Config, upgradeFuncs callbacks.RollingUpgradeFuncs, collectors metrics.Collectors, recorder record.EventRecorder, strategy invokeStrategy) error {
-
 	err := PerformAction(clients, config, upgradeFuncs, collectors, recorder, strategy)
 	if err != nil {
 		logrus.Errorf("Rolling upgrade for '%s' failed with error = %v", config.ResourceName, err)
@@ -241,10 +217,9 @@ func PerformAction(clients kube.Clients, config util.Config, upgradeFuncs callba
 	items := upgradeFuncs.ItemsFunc(clients, config.Namespace)
 
 	for _, item := range items {
-		err := retry.RetryOnConflict(retry.DefaultRetry, func() error {
-			return upgradeResource(clients, config, upgradeFuncs, collectors, recorder, strategy, item)
+		err := retryOnConflict(retry.DefaultRetry, func(fetchResource bool) error {
+			return upgradeResource(clients, config, upgradeFuncs, collectors, recorder, strategy, item, fetchResource)
 		})
-
 		if err != nil {
 			return err
 		}
@@ -253,16 +228,40 @@ func PerformAction(clients kube.Clients, config util.Config, upgradeFuncs callba
 	return nil
 }
 
-func upgradeResource(clients kube.Clients, config util.Config, upgradeFuncs callbacks.RollingUpgradeFuncs, collectors metrics.Collectors, recorder record.EventRecorder, strategy invokeStrategy, resource runtime.Object) error {
+func retryOnConflict(backoff wait.Backoff, fn func(_ bool) error) error {
+	var lastError error
+	fetchResource := false // do not fetch resource on first attempt, already done by ItemsFunc
+	err := wait.ExponentialBackoff(backoff, func() (bool, error) {
+		err := fn(fetchResource)
+		fetchResource = true
+		switch {
+		case err == nil:
+			return true, nil
+		case apierrors.IsConflict(err):
+			lastError = err
+			return false, nil
+		default:
+			return false, err
+		}
+	})
+	if wait.Interrupted(err) {
+		err = lastError
+	}
+	return err
+}
+
+func upgradeResource(clients kube.Clients, config util.Config, upgradeFuncs callbacks.RollingUpgradeFuncs, collectors metrics.Collectors, recorder record.EventRecorder, strategy invokeStrategy, resource runtime.Object, fetchResource bool) error {
 	accessor, err := meta.Accessor(resource)
 	if err != nil {
 		return err
 	}
 
 	resourceName := accessor.GetName()
-	resource, err = upgradeFuncs.ItemFunc(clients, resourceName, config.Namespace)
-	if err != nil {
-		return err
+	if fetchResource {
+		resource, err = upgradeFuncs.ItemFunc(clients, resourceName, config.Namespace)
+		if err != nil {
+			return err
+		}
 	}
 
 	// find correct annotation and update the resource

internal/pkg/handler/upgrade_test.go

@@ -1441,6 +1441,18 @@ func TestRollingUpgradeForDeploymentWithConfigmapUsingArs(t *testing.T) {
 	deploymentFuncs := GetDeploymentRollingUpgradeFuncs()
 	collectors := getCollectors()
 
+	itemCalled := 0
+	itemsCalled := 0
+
+	deploymentFuncs.ItemFunc = func(client kube.Clients, namespace string, name string) (runtime.Object, error) {
+		itemCalled++
+		return callbacks.GetDeploymentItem(client, namespace, name)
+	}
+	deploymentFuncs.ItemsFunc = func(client kube.Clients, namespace string) []runtime.Object {
+		itemsCalled++
+		return callbacks.GetDeploymentItems(client, namespace)
+	}
+
 	err := PerformAction(clients, config, deploymentFuncs, collectors, nil, invokeReloadStrategy)
 	time.Sleep(5 * time.Second)
 	if err != nil {
@@ -1460,6 +1472,10 @@ func TestRollingUpgradeForDeploymentWithConfigmapUsingArs(t *testing.T) {
 	if promtestutil.ToFloat64(collectors.ReloadedByNamespace.With(prometheus.Labels{"success": "true", "namespace": arsNamespace})) != 1 {
 		t.Errorf("Counter by namespace was not increased")
 	}
+
+	assert.Equal(t, 0, itemCalled, "ItemFunc should not be called")
+	assert.Equal(t, 2, itemsCalled, "ItemsFunc should be called twice")
+
 	testRollingUpgradeInvokeDeleteStrategyArs(t, clients, config, deploymentFuncs, collectors, envVarPostfix)
 }
 
@@ -1474,6 +1490,18 @@ func TestRollingUpgradeForDeploymentWithPatchAndRetryUsingArs(t *testing.T) {
 	assert.True(t, deploymentFuncs.SupportsPatch)
 	assert.NotEmpty(t, deploymentFuncs.PatchTemplatesFunc().AnnotationTemplate)
 
+	itemCalled := 0
+	itemsCalled := 0
+
+	deploymentFuncs.ItemFunc = func(client kube.Clients, namespace string, name string) (runtime.Object, error) {
+		itemCalled++
+		return callbacks.GetDeploymentItem(client, namespace, name)
+	}
+	deploymentFuncs.ItemsFunc = func(client kube.Clients, namespace string) []runtime.Object {
+		itemsCalled++
+		return callbacks.GetDeploymentItems(client, namespace)
+	}
+
 	patchCalled := 0
 	deploymentFuncs.PatchFunc = func(client kube.Clients, namespace string, resource runtime.Object, patchType patchtypes.PatchType, bytes []byte) error {
 		patchCalled++
@@ -1498,7 +1526,9 @@ func TestRollingUpgradeForDeploymentWithPatchAndRetryUsingArs(t *testing.T) {
 		t.Errorf("Rolling upgrade failed for Deployment with Configmap")
 	}
 
-	assert.Equal(t, 2, patchCalled)
+	assert.Equal(t, 1, itemCalled, "ItemFunc should be called once")
+	assert.Equal(t, 1, itemsCalled, "ItemsFunc should be called once")
+	assert.Equal(t, 2, patchCalled, "PatchFunc should be called twice")
 
 	deploymentFuncs = GetDeploymentRollingUpgradeFuncs()
 	testRollingUpgradeWithPatchAndInvokeDeleteStrategyArs(t, clients, config, deploymentFuncs, collectors, envVarPostfix)
@@ -2204,6 +2234,18 @@ func TestRollingUpgradeForDaemonSetWithConfigmapUsingArs(t *testing.T) {
 	daemonSetFuncs := GetDaemonSetRollingUpgradeFuncs()
 	collectors := getCollectors()
 
+	itemCalled := 0
+	itemsCalled := 0
+
+	daemonSetFuncs.ItemFunc = func(client kube.Clients, namespace string, name string) (runtime.Object, error) {
+		itemCalled++
+		return callbacks.GetDaemonSetItem(client, namespace, name)
+	}
+	daemonSetFuncs.ItemsFunc = func(client kube.Clients, namespace string) []runtime.Object {
+		itemsCalled++
+		return callbacks.GetDaemonSetItems(client, namespace)
+	}
+
 	err := PerformAction(clients, config, daemonSetFuncs, collectors, nil, invokeReloadStrategy)
 	time.Sleep(5 * time.Second)
 	if err != nil {
@@ -2224,6 +2266,9 @@ func TestRollingUpgradeForDaemonSetWithConfigmapUsingArs(t *testing.T) {
 		t.Errorf("Counter by namespace was not increased")
 	}
 
+	assert.Equal(t, 0, itemCalled, "ItemFunc should not be called")
+	assert.Equal(t, 2, itemsCalled, "ItemsFunc should be called twice")
+
 	testRollingUpgradeInvokeDeleteStrategyArs(t, clients, config, daemonSetFuncs, collectors, envVarPostfix)
 }
 
@@ -2235,6 +2280,18 @@ func TestRollingUpgradeForDaemonSetWithPatchAndRetryUsingArs(t *testing.T) {
 	config := getConfigWithAnnotations(envVarPostfix, arsConfigmapName, shaData, options.ConfigmapUpdateOnChangeAnnotation, options.ConfigmapReloaderAutoAnnotation)
 	daemonSetFuncs := GetDaemonSetRollingUpgradeFuncs()
 
+	itemCalled := 0
+	itemsCalled := 0
+
+	daemonSetFuncs.ItemFunc = func(client kube.Clients, namespace string, name string) (runtime.Object, error) {
+		itemCalled++
+		return callbacks.GetDaemonSetItem(client, namespace, name)
+	}
+	daemonSetFuncs.ItemsFunc = func(client kube.Clients, namespace string) []runtime.Object {
+		itemsCalled++
+		return callbacks.GetDaemonSetItems(client, namespace)
+	}
+
 	assert.True(t, daemonSetFuncs.SupportsPatch)
 	assert.NotEmpty(t, daemonSetFuncs.PatchTemplatesFunc().AnnotationTemplate)
 
@@ -2263,7 +2320,9 @@ func TestRollingUpgradeForDaemonSetWithPatchAndRetryUsingArs(t *testing.T) {
 		t.Errorf("Rolling upgrade failed for DaemonSet with configmap")
 	}
 
-	assert.Equal(t, 2, patchCalled)
+	assert.Equal(t, 1, itemCalled, "ItemFunc should be called once")
+	assert.Equal(t, 1, itemsCalled, "ItemsFunc should be called once")
+	assert.Equal(t, 2, patchCalled, "PatchFunc should be called twice")
 
 	daemonSetFuncs = GetDeploymentRollingUpgradeFuncs()
 	testRollingUpgradeWithPatchAndInvokeDeleteStrategyArs(t, clients, config, daemonSetFuncs, collectors, envVarPostfix)
@@ -2406,6 +2465,18 @@ func TestRollingUpgradeForStatefulSetWithConfigmapUsingArs(t *testing.T) {
 	statefulSetFuncs := GetStatefulSetRollingUpgradeFuncs()
 	collectors := getCollectors()
 
+	itemCalled := 0
+	itemsCalled := 0
+
+	statefulSetFuncs.ItemFunc = func(client kube.Clients, namespace string, name string) (runtime.Object, error) {
+		itemCalled++
+		return callbacks.GetStatefulSetItem(client, namespace, name)
+	}
+	statefulSetFuncs.ItemsFunc = func(client kube.Clients, namespace string) []runtime.Object {
+		itemsCalled++
+		return callbacks.GetStatefulSetItems(client, namespace)
+	}
+
 	err := PerformAction(clients, config, statefulSetFuncs, collectors, nil, invokeReloadStrategy)
 	time.Sleep(5 * time.Second)
 	if err != nil {
@@ -2426,6 +2497,9 @@ func TestRollingUpgradeForStatefulSetWithConfigmapUsingArs(t *testing.T) {
 		t.Errorf("Counter by namespace was not increased")
 	}
 
+	assert.Equal(t, 0, itemCalled, "ItemFunc should not be called")
+	assert.Equal(t, 2, itemsCalled, "ItemsFunc should be called twice")
+
 	testRollingUpgradeInvokeDeleteStrategyArs(t, clients, config, statefulSetFuncs, collectors, envVarPostfix)
 }
 
@@ -2437,6 +2511,18 @@ func TestRollingUpgradeForStatefulSetWithPatchAndRetryUsingArs(t *testing.T) {
 	config := getConfigWithAnnotations(envVarPostfix, arsConfigmapName, shaData, options.ConfigmapUpdateOnChangeAnnotation, options.ConfigmapReloaderAutoAnnotation)
 	statefulSetFuncs := GetStatefulSetRollingUpgradeFuncs()
 
+	itemCalled := 0
+	itemsCalled := 0
+
+	statefulSetFuncs.ItemFunc = func(client kube.Clients, namespace string, name string) (runtime.Object, error) {
+		itemCalled++
+		return callbacks.GetStatefulSetItem(client, namespace, name)
+	}
+	statefulSetFuncs.ItemsFunc = func(client kube.Clients, namespace string) []runtime.Object {
+		itemsCalled++
+		return callbacks.GetStatefulSetItems(client, namespace)
+	}
+
 	assert.True(t, statefulSetFuncs.SupportsPatch)
 	assert.NotEmpty(t, statefulSetFuncs.PatchTemplatesFunc().AnnotationTemplate)
 
@@ -2465,7 +2551,9 @@ func TestRollingUpgradeForStatefulSetWithPatchAndRetryUsingArs(t *testing.T) {
 		t.Errorf("Rolling upgrade failed for StatefulSet with configmap")
 	}
 
-	assert.Equal(t, 2, patchCalled)
+	assert.Equal(t, 1, itemCalled, "ItemFunc should be called once")
+	assert.Equal(t, 1, itemsCalled, "ItemsFunc should be called once")
+	assert.Equal(t, 2, patchCalled, "PatchFunc should be called twice")
 
 	statefulSetFuncs = GetDeploymentRollingUpgradeFuncs()
 	testRollingUpgradeWithPatchAndInvokeDeleteStrategyArs(t, clients, config, statefulSetFuncs, collectors, envVarPostfix)