Repository: kedacore/keda

Issue:
Incorrect log lines in e2e tests

In the tests, a specific time is waited for a `TestScaleIn` or `TestScaleOut`. These times may not match the log entry.
For example, the Dynatrace scaler states that it waits 60 seconds and does so three times, so 3 minutes.
If it fails, a log entry appears stating that it failed to complete the process within the specified timeframe. The example below states 2 minutes. That is incorrect, it should be 3 minutes.

https://github.com/kedacore/keda/blob/56a023d95864d4219f3109ba5a31ca0fe84ee05b/tests/scalers/dynatrace/dynatrace_test.go#L165-L171

This may be incorrect for other scalers.

This issue is here to see where this might be incorrect and correct this.


Discussion:
@elieserr: In https://github.com/kedacore/keda/blob/main/tests/helper/helper.go#L466 we can see max duration should be iterations * intervalSeconds. So for this case should be 3 min.
Will fix the log for this and other scalers.@elieserr: /assign

Solution patch:
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 71cabf0d0..6053a89d5 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,3 +1,3 @@
 # These owners will be the default owners for everything in
 # the repo. Unless a later match takes precedence
-*       @kedacore/keda-core-contributors
+*       @kedacore/keda-core-maintainers
diff --git a/.github/cherry-pick-bot.yml b/.github/cherry-pick-bot.yml
deleted file mode 100644
index 1f62315d7..000000000
--- a/.github/cherry-pick-bot.yml
+++ /dev/null
@@ -1,2 +0,0 @@
-enabled: true
-preservePullRequestTitle: true
diff --git a/.github/reviewers.yaml b/.github/reviewers.yaml
new file mode 100644
index 000000000..07c927f63
--- /dev/null
+++ b/.github/reviewers.yaml
@@ -0,0 +1,4 @@
+# https://github.com/marketplace/actions/auto-assign-reviewer-by-files
+"**/*":
+  - team: keda-core-contributors
+  - team: keda-core-maintainers
diff --git a/.github/workflows/pr-e2e.yml b/.github/workflows/pr-e2e.yml
index 4ca91feae..7766c7752 100644
--- a/.github/workflows/pr-e2e.yml
+++ b/.github/workflows/pr-e2e.yml
@@ -69,7 +69,7 @@ jobs:
 
   build-test-images:
     needs: triage
-    runs-on: ubuntu-latest
+    runs-on: ARM64
     name: Build images
     container: ghcr.io/kedacore/keda-tools:1.23.8
     if: needs.triage.outputs.run-e2e == 'true'
diff --git a/.github/workflows/pr-notify.yml b/.github/workflows/pr-notify.yml
new file mode 100644
index 000000000..cb773260f
--- /dev/null
+++ b/.github/workflows/pr-notify.yml
@@ -0,0 +1,12 @@
+name: Auto Assign
+on:
+  - pull_request_target
+
+jobs:
+  assign_reviewer:
+    runs-on: ARM64
+    steps:
+      - uses: shufo/auto-assign-reviewer-by-files@0a7fae44d02e841755d0caaac2ef05ad12a3bbc9 # v1.2.1
+        with:
+          config: ".github/reviewers.yml"
+          token: ${{ secrets.GH_AUTOMATION_PAT }}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7432f5c75..f3a3f203e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -63,6 +63,7 @@ To learn more about active deprecations, we recommend checking [GitHub Discussio
 
 ### New
 
+- **General**: Add error and event for mismatching input property ([#6721](https://github.com/kedacore/keda/issues/6721))
 - **General**: Enable support on s390x for KEDA ([#6543](https://github.com/kedacore/keda/issues/6543))
 - **General**: Introduce new Solace Direct Messaging scaler ([#6545](https://github.com/kedacore/keda/issues/6545))
 - **General**: Introduce new Sumo Logic Scaler ([#6734](https://github.com/kedacore/keda/issues/6734))
diff --git a/pkg/scalers/scalersconfig/typed_config.go b/pkg/scalers/scalersconfig/typed_config.go
index d339c7d47..80a4cbfa5 100644
--- a/pkg/scalers/scalersconfig/typed_config.go
+++ b/pkg/scalers/scalersconfig/typed_config.go
@@ -29,7 +29,9 @@ import (
 	"strings"
 	"time"
 
+	"github.com/go-logr/logr"
 	corev1 "k8s.io/api/core/v1"
+	logf "sigs.k8s.io/controller-runtime/pkg/log"
 
 	"github.com/kedacore/keda/v2/pkg/eventreason"
 )
@@ -150,21 +152,30 @@ func (sc *ScalerConfig) TypedConfig(typedConfig any) (err error) {
 			err = fmt.Errorf("failed to parse typed config %T resulted in panic\n%v", r, string(debug.Stack()))
 		}
 	}()
-	err = sc.parseTypedConfig(typedConfig, false)
+
+	logger := logf.Log.WithName("typed_config").WithValues("type", sc.ScalableObjectType, "namespace", sc.ScalableObjectNamespace, "name", sc.ScalableObjectName)
+
+	parsedParamNames, err := sc.parseTypedConfig(typedConfig, false)
+
+	if err == nil {
+		sc.checkUnexpectedParameterExist(parsedParamNames, logger)
+	}
+
 	return
 }
 
 // parseTypedConfig is a function that is used to unmarshal the TriggerMetadata, ResolvedEnv and AuthParams
 // this can be called recursively to parse nested structures
-func (sc *ScalerConfig) parseTypedConfig(typedConfig any, parentOptional bool) error {
+func (sc *ScalerConfig) parseTypedConfig(typedConfig any, parentOptional bool) ([]string, error) {
 	t := reflect.TypeOf(typedConfig)
 	if t.Kind() != reflect.Pointer {
-		return fmt.Errorf("typedConfig must be a pointer")
+		return nil, fmt.Errorf("typedConfig must be a pointer")
 	}
 	t = t.Elem()
 	v := reflect.ValueOf(typedConfig).Elem()
 
 	errs := []error{}
+	parsedParamNames := []string{}
 	for i := 0; i < t.NumField(); i++ {
 		fieldType := t.Field(i)
 		fieldValue := v.Field(i)
@@ -178,8 +189,11 @@ func (sc *ScalerConfig) parseTypedConfig(typedConfig any, parentOptional bool) e
 			continue
 		}
 		tagParams.Optional = tagParams.Optional || parentOptional
-		if err := sc.setValue(fieldValue, tagParams); err != nil {
+		parsed, err := sc.setValue(fieldValue, tagParams)
+		if err != nil {
 			errs = append(errs, err)
+		} else {
+			parsedParamNames = append(parsedParamNames, parsed...)
 		}
 	}
 	if validator, ok := typedConfig.(CustomValidator); ok {
@@ -187,14 +201,14 @@ func (sc *ScalerConfig) parseTypedConfig(typedConfig any, parentOptional bool) e
 			errs = append(errs, err)
 		}
 	}
-	return errors.Join(errs...)
+	return parsedParamNames, errors.Join(errs...)
 }
 
-// setValue is a function that sets the value of the field based on the provided params
-func (sc *ScalerConfig) setValue(field reflect.Value, params Params) error {
+// setValue is a function that sets the value of the field based on the provided params, will return error and param names that set value
+func (sc *ScalerConfig) setValue(field reflect.Value, params Params) ([]string, error) {
 	valFromConfig, exists := sc.configParamValue(params)
 	if exists && params.IsDeprecated() {
-		return fmt.Errorf("scaler %s info: %s", sc.TriggerType, params.Deprecated)
+		return nil, fmt.Errorf("scaler %s info: %s", sc.TriggerType, params.Deprecated)
 	}
 	if exists && params.DeprecatedAnnounce != "" {
 		if sc.Recorder != nil {
@@ -208,14 +222,14 @@ func (sc *ScalerConfig) setValue(field reflect.Value, params Params) error {
 		valFromConfig = params.Default
 	}
 	if !exists && (params.Optional || params.IsDeprecated()) {
-		return nil
+		return nil, nil
 	}
 	if !exists && !(params.Optional || params.IsDeprecated()) {
 		if len(params.Order) == 0 {
 			apo := slices.Sorted(maps.Keys(allowedParsingOrderMap))
-			return fmt.Errorf("missing required parameter %q, no 'order' tag, provide any from %v", params.Name(), apo)
+			return nil, fmt.Errorf("missing required parameter %q, no 'order' tag, provide any from %v", params.Name(), apo)
 		}
-		return fmt.Errorf("missing required parameter %q in %v", params.Name(), params.Order)
+		return nil, fmt.Errorf("missing required parameter %q in %v", params.Name(), params.Order)
 	}
 	if params.Enum != nil {
 		enumMap := make(map[string]bool)
@@ -231,7 +245,7 @@ func (sc *ScalerConfig) setValue(field reflect.Value, params Params) error {
 			}
 		}
 		if len(missingMap) > 0 {
-			return fmt.Errorf("parameter %q value %q must be one of %v", params.Name(), valFromConfig, params.Enum)
+			return nil, fmt.Errorf("parameter %q value %q must be one of %v", params.Name(), valFromConfig, params.Enum)
 		}
 	}
 	if params.ExclusiveSet != nil {
@@ -248,7 +262,7 @@ func (sc *ScalerConfig) setValue(field reflect.Value, params Params) error {
 			}
 		}
 		if exclusiveCount > 1 {
-			return fmt.Errorf("parameter %q value %q must contain only one of %v", params.Name(), valFromConfig, params.ExclusiveSet)
+			return nil, fmt.Errorf("parameter %q value %q must contain only one of %v", params.Name(), valFromConfig, params.ExclusiveSet)
 		}
 	}
 	if params.IsNested() {
@@ -257,14 +271,14 @@ func (sc *ScalerConfig) setValue(field reflect.Value, params Params) error {
 			field = field.Elem()
 		}
 		if field.Kind() != reflect.Struct {
-			return fmt.Errorf("nested parameter %q must be a struct, has kind %q", params.FieldName, field.Kind())
+			return nil, fmt.Errorf("nested parameter %q must be a struct, has kind %q", params.FieldName, field.Kind())
 		}
 		return sc.parseTypedConfig(field.Addr().Interface(), params.Optional)
 	}
 	if err := setConfigValueHelper(params, valFromConfig, field); err != nil {
-		return fmt.Errorf("unable to set param %q value %q: %w", params.Name(), valFromConfig, err)
+		return nil, fmt.Errorf("unable to set param %q value %q: %w", params.Name(), valFromConfig, err)
 	}
-	return nil
+	return []string{params.Name()}, nil
 }
 
 // setConfigValueURLParams is a function that sets the value of the url.Values field
@@ -470,6 +484,25 @@ func (sc *ScalerConfig) configParamValue(params Params) (string, bool) {
 	return "", params.IsNested()
 }
 
+// checkUnexpectedParameterExist is a function that checks if there are any unexpected parameters in the TriggerMetadata
+func (sc *ScalerConfig) checkUnexpectedParameterExist(parsedParamNames []string, logger logr.Logger) {
+	for k := range sc.TriggerMetadata {
+		suffix := "FromEnv"
+		if !strings.HasSuffix(k, "FromEnv") {
+			suffix = ""
+		}
+		key := strings.TrimSuffix(k, suffix)
+		if !slices.Contains(parsedParamNames, key) {
+			if sc.Recorder != nil {
+				message := fmt.Sprintf("Unmatched input property %s in scaler %s", key+suffix, sc.ScalableObjectType)
+				// Just logging as it's optional property checking and should not block the scaling
+				logger.Error(nil, message)
+				sc.Recorder.Event(sc.ScaledObject, corev1.EventTypeWarning, eventreason.KEDAScalersInfo, message)
+			}
+		}
+	}
+}
+
 // paramsFromTag is a function that returns the Params struct based on the field tag
 func paramsFromTag(tag string, field reflect.StructField) (Params, error) {
 	params := Params{FieldName: field.Name}



Test patch:
diff --git a/pkg/scalers/scalersconfig/typed_config_test.go b/pkg/scalers/scalersconfig/typed_config_test.go
index c566e8762..0f7e19a97 100644
--- a/pkg/scalers/scalersconfig/typed_config_test.go
+++ b/pkg/scalers/scalersconfig/typed_config_test.go
@@ -610,15 +610,56 @@ func TestMultiName(t *testing.T) {
 	Expect(ts.Property).To(Equal("bbb"))
 }
 
+// TestUnexpectedOptional tests the unexpected optional input
+func TestUnexpectedOptional(t *testing.T) {
+	RegisterTestingT(t)
+
+	// Create a mock recorder to capture the event
+	mockRecorder := &MockEventRecorder{Messages: make([]string, 0)}
+
+	sc := &ScalerConfig{
+		TriggerMetadata: map[string]string{
+			"stringVal":     "value1",
+			"nestVal":       "nestVal",
+			"notexistVal":   "aaa",
+			"notValFromEnv": "bbb",
+		},
+		ResolvedEnv: map[string]string{
+			"bbb": "1.1",
+		},
+		Recorder:           mockRecorder,
+		ScalableObjectType: "test",
+	}
+	type nestStruct struct {
+		Nest string `keda:"name=nestVal, order=triggerMetadata"`
+	}
+
+	type testStruct struct {
+		BA        nestStruct `keda:""`
+		StringVal string     `keda:"name=stringVal, order=triggerMetadata"`
+	}
+
+	ts := testStruct{}
+	err := sc.TypedConfig(&ts)
+	Expect(err).To(BeNil())
+
+	// Verify that the event was recorded
+	Expect(mockRecorder.EventCalled).To(BeTrue())
+	Expect(mockRecorder.Messages[0]).To(Equal("Unmatched input property notexistVal in scaler test"))
+	Expect(mockRecorder.Messages[1]).To(Equal("Unmatched input property notValFromEnv in scaler test"))
+}
+
 // MockEventRecorder is a mock implementation of record.EventRecorder
 type MockEventRecorder struct {
 	EventCalled bool
 	Message     string
+	Messages    []string
 }
 
 func (m *MockEventRecorder) Event(object runtime.Object, eventtype, reason, message string) {
 	m.EventCalled = true
 	m.Message = message
+	m.Messages = append(m.Messages, message)
 }
 
 func (m *MockEventRecorder) Eventf(object runtime.Object, eventtype, reason, messageFmt string, args ...interface{}) {
diff --git a/tests/README.md b/tests/README.md
index 7b198a7eb..6fd0af236 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -192,6 +192,7 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset) {
     ...
     ...
     // Sleep / poll for replica count using helper method.
+    // Duration should be iterations * intervalSeconds
     require.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 10, 60, 1),
 		"replica count should be 10 after 1 minute")
 }
diff --git a/tests/internals/fallback/fallback_test.go b/tests/internals/fallback/fallback_test.go
index 09bf1aa58..3ef334b42 100644
--- a/tests/internals/fallback/fallback_test.go
+++ b/tests/internals/fallback/fallback_test.go
@@ -420,7 +420,7 @@ func TestFallback(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	testScaleOut(t, kc, data)
 	testFallback(t, kc, data)
@@ -446,7 +446,7 @@ func TestFallbackWithScaledObjectWithoutMetricType(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	// Scale out to 4 replicas (20 / 5 = 4)
 	data.MetricValue = 20
@@ -485,7 +485,7 @@ func TestFallbackWithCurrentReplicasIfHigher(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	// Scale out to 4 replicas (20 / 5 = 4)
 	data.MetricValue = 20
@@ -524,7 +524,7 @@ func TestFallbackWithCurrentReplicasIfLower(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	// Scale out to 4 replicas (20 / 5 = 4)
 	data.MetricValue = 20
@@ -563,7 +563,7 @@ func TestFallbackWithCurrentReplicas(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	// Scale out to 4 replicas (20 / 5 = 4)
 	data.MetricValue = 20
@@ -602,7 +602,7 @@ func TestFallbackWithStatic(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	// Scale out to 4 replicas (20 / 5 = 4)
 	data.MetricValue = 20
diff --git a/tests/internals/global_custom_ca/global_custom_ca_test.go b/tests/internals/global_custom_ca/global_custom_ca_test.go
index d7c2ab9ef..3f4b4853b 100644
--- a/tests/internals/global_custom_ca/global_custom_ca_test.go
+++ b/tests/internals/global_custom_ca/global_custom_ca_test.go
@@ -227,7 +227,7 @@ func TestCustomCa(t *testing.T) {
 	CreateKubernetesResources(t, kc, testNamespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicaCount, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicaCount)
+		"replica count should be %d after 9 minutes", minReplicaCount)
 
 	// test scaling
 	testScaleOut(t, kc, data)
diff --git a/tests/internals/polling_cooldown_so/polling_cooldown_so_test.go b/tests/internals/polling_cooldown_so/polling_cooldown_so_test.go
index 29766f1f3..626fdebb6 100644
--- a/tests/internals/polling_cooldown_so/polling_cooldown_so_test.go
+++ b/tests/internals/polling_cooldown_so/polling_cooldown_so_test.go
@@ -269,7 +269,7 @@ func testPollingIntervalDown(t *testing.T, kc *kubernetes.Clientset, data templa
 	AssertReplicaCountNotChangeDuringTimePeriod(t, kc, deploymentName, namespace, maxReplicas, 60)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 12, 10),
-		"replica count should be %d after 1 minutes", maxReplicas)
+		"replica count should be %d after 2 minutes", maxReplicas)
 
 	KubectlDeleteWithTemplate(t, data, "scaledObjectTemplate", scaledObjectTemplate)
 }
diff --git a/tests/internals/replica_update_so/replica_update_so_test.go b/tests/internals/replica_update_so/replica_update_so_test.go
index e77d68e18..796d7d3b3 100644
--- a/tests/internals/replica_update_so/replica_update_so_test.go
+++ b/tests/internals/replica_update_so/replica_update_so_test.go
@@ -220,14 +220,14 @@ func scaleMaxReplicasUp(t *testing.T, kc *kubernetes.Clientset, data templateDat
 	KubectlApplyWithTemplate(t, data, "scaledObjectTriggerTemplate", scaledObjectTriggerTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, maxReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", maxReplicas)
+		"replica count should be %d after 9 minutes", maxReplicas)
 
 	updatedMaxReplicas := maxReplicas + 10
 	data.MaxReplicas = strconv.Itoa(updatedMaxReplicas)
 	KubectlApplyWithTemplate(t, data, "scaledObjectTriggerTemplate", scaledObjectTriggerTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, updatedMaxReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", updatedMaxReplicas)
+		"replica count should be %d after 9 minutes", updatedMaxReplicas)
 }
 
 // expect replicas to decrease because maxReplicas was updated
@@ -241,13 +241,13 @@ func scaleMaxReplicasDown(t *testing.T, kc *kubernetes.Clientset, data templateD
 	KubectlApplyWithTemplate(t, data, "scaledObjectTriggerTemplate", scaledObjectTriggerTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, updatedMaxReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", updatedMaxReplicas)
+		"replica count should be %d after 9 minutes", updatedMaxReplicas)
 
 	data.MaxReplicas = strconv.Itoa(maxReplicas)
 	KubectlApplyWithTemplate(t, data, "scaledObjectTriggerTemplate", scaledObjectTriggerTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, maxReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", maxReplicas)
+		"replica count should be %d after 9 minutes", maxReplicas)
 }
 
 // starts with minReplicas 0 -> update to higher, expect to scale up
@@ -259,14 +259,14 @@ func scaleMinReplicasUpFromZero(t *testing.T, kc *kubernetes.Clientset, data tem
 	KubectlApplyWithTemplate(t, data, "scaledObjectTriggerTemplate", scaledObjectTriggerTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	updatedMinReplicas := minReplicas + 5
 	data.MinReplicas = strconv.Itoa(updatedMinReplicas)
 	KubectlApplyWithTemplate(t, data, "scaledObjectTriggerTemplate", scaledObjectTriggerTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, updatedMinReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", updatedMinReplicas)
+		"replica count should be %d after 9 minutes", updatedMinReplicas)
 }
 
 // starts with 5 replicas as minReplicas -> update to 0, expect to scale down
@@ -281,7 +281,7 @@ func scaleMinReplicasDownToZero(t *testing.T, kc *kubernetes.Clientset, data tem
 	KubectlApplyWithTemplate(t, data, "scaledObjectTriggerTemplate", scaledObjectTriggerTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, updatedMinReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", updatedMinReplicas)
+		"replica count should be %d after 9 minutes", updatedMinReplicas)
 
 	// change minReplicas to default (0)
 	data.MinReplicas = strconv.Itoa(minReplicas)
@@ -289,7 +289,7 @@ func scaleMinReplicasDownToZero(t *testing.T, kc *kubernetes.Clientset, data tem
 
 	// check it scales down to 0
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 }
 
 // help function to load template data
diff --git a/tests/internals/scaling_modifiers/scaling_modifiers_test.go b/tests/internals/scaling_modifiers/scaling_modifiers_test.go
index 860046b19..27f211c01 100644
--- a/tests/internals/scaling_modifiers/scaling_modifiers_test.go
+++ b/tests/internals/scaling_modifiers/scaling_modifiers_test.go
@@ -282,7 +282,7 @@ func TestScalingModifiers(t *testing.T) {
 
 	// we ensure that the metrics api server is up and ready
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, metricsServerDeploymentName, namespace, 1, 60, 2),
-		"replica count should be 1 after 1 minute")
+		"replica count should be 1 after 2 minutes")
 
 	testFormula(t, kc, data)
 
@@ -307,7 +307,7 @@ func testFormula(t *testing.T, kc *kubernetes.Clientset, data templateData) {
 	assert.NoErrorf(t, err, "cannot scale workload deployment - %s", err)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, "depl-workload-base", namespace, 2, 12, 10),
-		"replica count should be %d after 1 minute", 2)
+		"replica count should be %d after 2 minutes", 2)
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, 3, 12, 10),
 		"replica count should be %d after 2 minutes", 3)
 
@@ -326,7 +326,7 @@ func testFormula(t *testing.T, kc *kubernetes.Clientset, data templateData) {
 
 	// we ensure that the metrics api server is up and ready
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, metricsServerDeploymentName, namespace, 1, 60, 2),
-		"replica count should be 1 after 1 minute")
+		"replica count should be 1 after 2 minutes")
 
 	data.MetricValue = 2
 	KubectlReplaceWithTemplate(t, data, "updateMetricsTemplate", updateMetricsTemplate)
diff --git a/tests/internals/trigger_update_so/trigger_update_so_test.go b/tests/internals/trigger_update_so/trigger_update_so_test.go
index 0e400f4b2..598fb804b 100644
--- a/tests/internals/trigger_update_so/trigger_update_so_test.go
+++ b/tests/internals/trigger_update_so/trigger_update_so_test.go
@@ -301,7 +301,7 @@ func TestScaledObjectGeneral(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	testTargetValue(t, kc, data)          // one trigger target changes
 	testTwoTriggers(t, kc, data)          // add trigger during active scaling
@@ -320,21 +320,21 @@ func testTargetValue(t *testing.T, kc *kubernetes.Clientset, data templateData)
 	KubectlReplaceWithTemplate(t, data, "updateMetricTemplate", updateMetricTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, 1, 180, 3),
-		"replica count should be %d after 3 minutes", 1)
+		"replica count should be %d after 9 minutes", 1)
 
 	t.Log("--- test target value 10 ---")
 	data.MetricValue = 10
 	KubectlReplaceWithTemplate(t, data, "updateMetricTemplate", updateMetricTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, maxReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", maxReplicas)
+		"replica count should be %d after 9 minutes", maxReplicas)
 
 	t.Log("--- test target value 0 ---")
 	data.MetricValue = 0
 	KubectlReplaceWithTemplate(t, data, "updateMetricTemplate", updateMetricTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 }
 
 // test adding second trigger during scaling
@@ -346,14 +346,14 @@ func testTwoTriggers(t *testing.T, kc *kubernetes.Clientset, data templateData)
 	KubectlReplaceWithTemplate(t, data, "updateMetricTemplate", updateMetricTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, 1, 180, 3),
-		"replica count should be %d after 3 minutes", 1)
+		"replica count should be %d after 9 minutes", 1)
 
 	KubectlApplyWithTemplate(t, data, "scaledObjectTwoTriggerTemplate", scaledObjectTwoTriggerTemplate)
 	// scale to max with k8s wl = second trigger
 	KubernetesScaleDeployment(t, kc, workloadDeploymentName, int64(maxReplicas), namespace)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, maxReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", maxReplicas)
+		"replica count should be %d after 9 minutes", maxReplicas)
 }
 
 // scales to max with kubernetes worload(second trigger), removes it and
@@ -367,13 +367,13 @@ func testRemoveTrigger(t *testing.T, kc *kubernetes.Clientset, data templateData
 	KubernetesScaleDeployment(t, kc, workloadDeploymentName, int64(maxReplicas), namespace)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, maxReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", maxReplicas)
+		"replica count should be %d after 9 minutes", maxReplicas)
 
 	// update SO -> remove k8s wl == second trigger
 	KubectlApplyWithTemplate(t, data, "scaledObjectTriggerTemplate", scaledObjectTriggerTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, midReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", midReplicas)
+		"replica count should be %d after 9 minutes", midReplicas)
 }
 
 // test 3 triggers scaling works including one cpu metric
@@ -387,7 +387,7 @@ func testThreeTriggersWithCPU(t *testing.T, kc *kubernetes.Clientset, data templ
 	data.MetricValue = 10
 	KubectlReplaceWithTemplate(t, data, "updateMetricTemplate", updateMetricTemplate)
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, maxReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", maxReplicas)
+		"replica count should be %d after 9 minutes", maxReplicas)
 }
 
 // help function to load template data
diff --git a/tests/internals/update_ta/update_ta_test.go b/tests/internals/update_ta/update_ta_test.go
index 1a5ef57dc..0eeb5a98d 100644
--- a/tests/internals/update_ta/update_ta_test.go
+++ b/tests/internals/update_ta/update_ta_test.go
@@ -275,7 +275,7 @@ func TestTriggerAuthenticationGeneral(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	testTriggerAuthenticationStatusValue(t, data, triggerAuthKind)
 
@@ -287,7 +287,7 @@ func TestTriggerAuthenticationGeneral(t *testing.T) {
 	CreateKubernetesResources(t, kc, namespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, namespace, minReplicas, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicas)
+		"replica count should be %d after 9 minutes", minReplicas)
 
 	testTriggerAuthenticationStatusValue(t, data, clusterTriggerAuthKind)
 	DeleteKubernetesResources(t, namespace, data, templates)
diff --git a/tests/scalers/aws/aws_managed_prometheus/aws_managed_prometheus_test.go b/tests/scalers/aws/aws_managed_prometheus/aws_managed_prometheus_test.go
index 38448fefb..6df8b3c8f 100644
--- a/tests/scalers/aws/aws_managed_prometheus/aws_managed_prometheus_test.go
+++ b/tests/scalers/aws/aws_managed_prometheus/aws_managed_prometheus_test.go
@@ -150,7 +150,7 @@ func TestScaler(t *testing.T) {
 	t.Log("--- assert ---")
 	expectedReplicaCountNumber := 2 // as mentioned above, as the AMP returns 100 and the threshold set to 50, the expected replica count is 100 / 50 = 2
 	assert.Truef(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 60, 1),
-		"replica count should be %d after a minute", expectedReplicaCountNumber)
+		"replica count should be %d after 1 minute", expectedReplicaCountNumber)
 
 	t.Log("--- cleaning up ---")
 	deleteWSInput := amp.DeleteWorkspaceInput{
diff --git a/tests/scalers/aws/aws_managed_prometheus_pod_identity/aws_managed_prometheus_pod_identity_test.go b/tests/scalers/aws/aws_managed_prometheus_pod_identity/aws_managed_prometheus_pod_identity_test.go
index 5a9d152bb..77da1e6cf 100644
--- a/tests/scalers/aws/aws_managed_prometheus_pod_identity/aws_managed_prometheus_pod_identity_test.go
+++ b/tests/scalers/aws/aws_managed_prometheus_pod_identity/aws_managed_prometheus_pod_identity_test.go
@@ -135,7 +135,7 @@ func TestScaler(t *testing.T) {
 	t.Log("--- assert ---")
 	expectedReplicaCountNumber := 2 // as mentioned above, as the AMP returns 100 and the threshold set to 50, the expected replica count is 100 / 50 = 2
 	assert.Truef(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 60, 1),
-		"replica count should be %d after a minute", expectedReplicaCountNumber)
+		"replica count should be %d after 1 minute", expectedReplicaCountNumber)
 
 	t.Log("--- cleaning up ---")
 	deleteWSInput := amp.DeleteWorkspaceInput{
diff --git a/tests/scalers/beanstalkd/beanstalkd_test.go b/tests/scalers/beanstalkd/beanstalkd_test.go
index 214226084..6329c5f2b 100644
--- a/tests/scalers/beanstalkd/beanstalkd_test.go
+++ b/tests/scalers/beanstalkd/beanstalkd_test.go
@@ -183,7 +183,7 @@ func TestBeanstalkdScaler(t *testing.T) {
 	CreateKubernetesResources(t, kc, testNamespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, beanstalkdDeploymentName, testNamespace, 1, 60, 1),
-		"replica count should be 0 after a minute")
+		"replica count should be 0 after 1 minute")
 
 	// test activation
 	testActivation(t, kc, data)
@@ -245,7 +245,7 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset, data templateData) {
 	addBeanstalkdJobs(t, kc, &data)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 3, 60, 1),
-		"replica count should be 3 after a minute")
+		"replica count should be 3 after 1 minute")
 }
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset, data templateData) {
@@ -263,5 +263,5 @@ func testScaleIn(t *testing.T, kc *kubernetes.Clientset, data templateData) {
 	removeBeanstalkdJobs(t, kc, &data)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 60, 1),
-		"replica count should be 0 after a minute")
+		"replica count should be 0 after 1 minute")
 }
diff --git a/tests/scalers/cron/cron_test.go b/tests/scalers/cron/cron_test.go
index a0ff8c64d..c5f85e797 100644
--- a/tests/scalers/cron/cron_test.go
+++ b/tests/scalers/cron/cron_test.go
@@ -100,7 +100,7 @@ func TestScaler(t *testing.T) {
 	CreateKubernetesResources(t, kc, testNamespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 1, 60, 2),
-		"replica count should be 1 after 1 minute")
+		"replica count should be 1 after 2 minute")
 
 	// test scaling
 	testScaleOut(t, kc)
@@ -126,11 +126,11 @@ func getTemplateData() (templateData, []Template) {
 func testScaleOut(t *testing.T, kc *kubernetes.Clientset) {
 	t.Log("--- testing scale out ---")
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 4, 60, 2),
-		"replica count should be 4 after 1 minute")
+		"replica count should be 4 after 2 minutes")
 }
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
 	t.Log("--- testing scale in ---")
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 1, 60, 2),
-		"replica count should be 1 after 1 minute")
+		"replica count should be 1 after 2 minutes")
 }
diff --git a/tests/scalers/datadog/datadog_api/datadog_api_test.go b/tests/scalers/datadog/datadog_api/datadog_api_test.go
index 7027a1966..9a743023d 100644
--- a/tests/scalers/datadog/datadog_api/datadog_api_test.go
+++ b/tests/scalers/datadog/datadog_api/datadog_api_test.go
@@ -272,7 +272,7 @@ func TestDatadogScalerAPI(t *testing.T) {
 	KubectlApplyWithTemplate(t, data, "scaledObjectTemplate", scaledObjectTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicaCount, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicaCount)
+		"replica count should be %d after 9 minutes", minReplicaCount)
 
 	// test scaling
 	testActivation(t, kc, data)
diff --git a/tests/scalers/dynatrace/dynatrace_test.go b/tests/scalers/dynatrace/dynatrace_test.go
index 7d20231a9..08edd01c2 100644
--- a/tests/scalers/dynatrace/dynatrace_test.go
+++ b/tests/scalers/dynatrace/dynatrace_test.go
@@ -146,7 +146,7 @@ func TestDynatraceScaler(t *testing.T) {
 	CreateKubernetesResources(t, kc, testNamespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicaCount, 60, 1),
-		"replica count should be %s after a minute", minReplicaCount)
+		"replica count should be %s after 1 minute", minReplicaCount)
 
 	// test scaling
 	testActivation(t, kc)
@@ -167,7 +167,7 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset) {
 	stopCh := make(chan struct{})
 	go setMetricValue(t, 10, stopCh)
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, maxReplicaCount, 60, 3),
-		"replica count should be %d after 2 minutes", maxReplicaCount)
+		"replica count should be %d after 3 minutes", maxReplicaCount)
 	close(stopCh)
 }
 
@@ -177,7 +177,7 @@ func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
 	stopCh := make(chan struct{})
 	go setMetricValue(t, 0, stopCh)
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicaCount, 60, 3),
-		"replica count should be %d after 2 minutes", minReplicaCount)
+		"replica count should be %d after 3 minutes", minReplicaCount)
 	close(stopCh)
 }
 
diff --git a/tests/scalers/gcp/gcp_cloud_tasks/gcp_cloud_tasks_test.go b/tests/scalers/gcp/gcp_cloud_tasks/gcp_cloud_tasks_test.go
index 61cc92e5e..bb811921e 100644
--- a/tests/scalers/gcp/gcp_cloud_tasks/gcp_cloud_tasks_test.go
+++ b/tests/scalers/gcp/gcp_cloud_tasks/gcp_cloud_tasks_test.go
@@ -176,7 +176,7 @@ func TestScaler(t *testing.T) {
 	CreateKubernetesResources(t, kc, testNamespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 60, 1),
-		"replica count should be 0 after a minute")
+		"replica count should be 0 after 1 minute")
 
 	sdkReady := WaitForDeploymentReplicaReadyCount(t, kc, "gcp-sdk", testNamespace, 1, 60, 1)
 	assert.True(t, sdkReady, "gcp-sdk deployment should be ready after a minute")
@@ -273,7 +273,7 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset) {
 
 	t.Log("--- waiting for replicas to scale out ---")
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, maxReplicaCount, 30, 10),
-		fmt.Sprintf("replica count should be %d after five minutes", maxReplicaCount))
+		fmt.Sprintf("replica count should be %d after 5 minutes", maxReplicaCount))
 }
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
@@ -284,5 +284,5 @@ func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
 
 	t.Log("--- waiting for replicas to scale in to zero ---")
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 30, 10),
-		"replica count should be 0 after five minute")
+		"replica count should be 0 after 5 minute")
 }
diff --git a/tests/scalers/gcp/gcp_cloud_tasks_workload_identity/gcp_cloud_tasks_workload_identity_test.go b/tests/scalers/gcp/gcp_cloud_tasks_workload_identity/gcp_cloud_tasks_workload_identity_test.go
index 1de52b506..220750363 100644
--- a/tests/scalers/gcp/gcp_cloud_tasks_workload_identity/gcp_cloud_tasks_workload_identity_test.go
+++ b/tests/scalers/gcp/gcp_cloud_tasks_workload_identity/gcp_cloud_tasks_workload_identity_test.go
@@ -186,10 +186,10 @@ func TestScaler(t *testing.T) {
 	CreateKubernetesResources(t, kc, testNamespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 60, 1),
-		"replica count should be 0 after a minute")
+		"replica count should be 0 after 1 minute")
 
 	sdkReady := WaitForDeploymentReplicaReadyCount(t, kc, "gcp-sdk", testNamespace, 1, 60, 1)
-	assert.True(t, sdkReady, "gcp-sdk deployment should be ready after a minute")
+	assert.True(t, sdkReady, "gcp-sdk deployment should be ready after 1 minute")
 
 	if sdkReady {
 		if createGcpCloudTasks(t) == nil {
@@ -284,7 +284,7 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset) {
 
 	t.Log("--- waiting for replicas to scale out ---")
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, maxReplicaCount, 30, 10),
-		fmt.Sprintf("replica count should be %d after five minutes", maxReplicaCount))
+		fmt.Sprintf("replica count should be %d after 5 minutes", maxReplicaCount))
 }
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
@@ -295,5 +295,5 @@ func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
 
 	t.Log("--- waiting for replicas to scale in to zero ---")
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 30, 10),
-		"replica count should be 0 after five minute")
+		"replica count should be 0 after 5 minutes")
 }
diff --git a/tests/scalers/gcp/gcp_prometheus_workload_identity/gcp_prometheus_workload_identity_test.go b/tests/scalers/gcp/gcp_prometheus_workload_identity/gcp_prometheus_workload_identity_test.go
index ddf068bf3..b09906109 100644
--- a/tests/scalers/gcp/gcp_prometheus_workload_identity/gcp_prometheus_workload_identity_test.go
+++ b/tests/scalers/gcp/gcp_prometheus_workload_identity/gcp_prometheus_workload_identity_test.go
@@ -122,7 +122,7 @@ func TestScaler(t *testing.T) {
 	t.Log("--- assert ---")
 	expectedReplicaCountNumber := 2 // as mentioned above, as the GMP returns 100 and the threshold set to 50, the expected replica count is 100 / 50 = 2
 	assert.Truef(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, expectedReplicaCountNumber, 60, 1),
-		"replica count should be %d after a minute", expectedReplicaCountNumber)
+		"replica count should be %d after 1 minute", expectedReplicaCountNumber)
 
 	t.Log("--- cleaning up ---")
 	DeleteKubernetesResources(t, testNamespace, data, templates)
diff --git a/tests/scalers/gcp/gcp_pubsub/gcp_pubsub_test.go b/tests/scalers/gcp/gcp_pubsub/gcp_pubsub_test.go
index bfb943453..e88330c04 100644
--- a/tests/scalers/gcp/gcp_pubsub/gcp_pubsub_test.go
+++ b/tests/scalers/gcp/gcp_pubsub/gcp_pubsub_test.go
@@ -178,7 +178,7 @@ func TestScaler(t *testing.T) {
 	CreateKubernetesResources(t, kc, testNamespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 60, 1),
-		"replica count should be 0 after a minute")
+		"replica count should be 0 after 1 minute")
 
 	sdkReady := WaitForDeploymentReplicaReadyCount(t, kc, "gcp-sdk", testNamespace, 1, 60, 1)
 	assert.True(t, sdkReady, "gcp-sdk deployment should be ready after a minute")
@@ -282,7 +282,7 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset) {
 
 	t.Log("--- waiting for replicas to scale out ---")
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, maxReplicaCount, 30, 10),
-		fmt.Sprintf("replica count should be %d after five minutes", maxReplicaCount))
+		fmt.Sprintf("replica count should be %d after 5 minutes", maxReplicaCount))
 }
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
@@ -293,5 +293,5 @@ func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
 
 	t.Log("--- waiting for replicas to scale in to zero ---")
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 30, 10),
-		"replica count should be 0 after five minute")
+		"replica count should be 0 after 5 minutes")
 }
diff --git a/tests/scalers/kubernetes_workload/kubernetes_workload_test.go b/tests/scalers/kubernetes_workload/kubernetes_workload_test.go
index b72769762..2a76b3501 100644
--- a/tests/scalers/kubernetes_workload/kubernetes_workload_test.go
+++ b/tests/scalers/kubernetes_workload/kubernetes_workload_test.go
@@ -131,24 +131,24 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset) {
 	// scale monitored deployment to 5 replicas
 	KubernetesScaleDeployment(t, kc, monitoredDeploymentName, 5, testNamespace)
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, sutDeploymentName, testNamespace, 5, 60, 2),
-		"replica count should be 5 after 1 minute")
+		"replica count should be 5 after 2 minutes")
 
 	// scale monitored deployment to 10 replicas
 	KubernetesScaleDeployment(t, kc, monitoredDeploymentName, 10, testNamespace)
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, sutDeploymentName, testNamespace, 10, 60, 2),
-		"replica count should be 10 after 1 minute")
+		"replica count should be 10 after 2 minutes")
 }
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
 	// scale monitored deployment to 5 replicas
 	KubernetesScaleDeployment(t, kc, monitoredDeploymentName, 5, testNamespace)
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, sutDeploymentName, testNamespace, 5, 60, 2),
-		"replica count should be 5 after 1 minute")
+		"replica count should be 5 after 2 minutes")
 
 	// scale monitored deployment to 0 replicas
 	KubernetesScaleDeployment(t, kc, monitoredDeploymentName, 0, testNamespace)
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, sutDeploymentName, testNamespace, 0, 60, 2),
-		"replica count should be 0 after 1 minute")
+		"replica count should be 0 after 2 minutes")
 }
 
 func getTemplateData() (templateData, []Template) {
diff --git a/tests/scalers/metrics_api/metrics_api_test.go b/tests/scalers/metrics_api/metrics_api_test.go
index c3229502d..b339e5309 100644
--- a/tests/scalers/metrics_api/metrics_api_test.go
+++ b/tests/scalers/metrics_api/metrics_api_test.go
@@ -194,7 +194,7 @@ func TestScaler(t *testing.T) {
 	CreateKubernetesResources(t, kc, testNamespace, data, templates)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicaCount, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicaCount)
+		"replica count should be %d after 9 minutes", minReplicaCount)
 
 	// test scaling
 	testActivation(t, kc, data)
diff --git a/tests/scalers/mysql/mysql_test.go b/tests/scalers/mysql/mysql_test.go
index c192b5515..c1986fb50 100644
--- a/tests/scalers/mysql/mysql_test.go
+++ b/tests/scalers/mysql/mysql_test.go
@@ -291,9 +291,9 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset, data templateData) {
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset) {
 	t.Log("--- testing scale in ---")
-	// Check if deployment scale in to 0 after 5 minutes
+	// Check if deployment scale in to 0 after 6 minutes
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, 0, 360, 1),
-		"Replica count should be 0 after 5 minutes")
+		"Replica count should be 0 after 6 minutes")
 }
 
 func getTemplateData() (templateData, []Template) {
diff --git a/tests/scalers/redis/redis_standalone_streams_lag/redis_standalone_streams_lag_test.go b/tests/scalers/redis/redis_standalone_streams_lag/redis_standalone_streams_lag_test.go
index 4de773e5e..4571284f0 100644
--- a/tests/scalers/redis/redis_standalone_streams_lag/redis_standalone_streams_lag_test.go
+++ b/tests/scalers/redis/redis_standalone_streams_lag/redis_standalone_streams_lag_test.go
@@ -208,12 +208,12 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset, data templateData, num
 	KubectlReplaceWithTemplate(t, data, "insertJobTemplate", insertJobTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, maxReplicas, 60, 1),
-		"replica count should be %d after 3 minutes", maxReplicaCount)
+		"replica count should be %d after 1 minute", maxReplicaCount)
 }
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset, minReplicas int) {
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicas, 60, 1),
-		"replica count should be %d after 3 minutes", minReplicaCount)
+		"replica count should be %d after 1 minute", minReplicaCount)
 }
 
 func testActivationValue(t *testing.T, kc *kubernetes.Clientset, data templateData, numMessages int) {
diff --git a/tests/scalers/splunk/splunk_test.go b/tests/scalers/splunk/splunk_test.go
index 399d07495..328803842 100644
--- a/tests/scalers/splunk/splunk_test.go
+++ b/tests/scalers/splunk/splunk_test.go
@@ -232,11 +232,11 @@ func TestSplunkScaler(t *testing.T) {
 
 	// Wait for splunk to start
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, "splunk", testNamespace, 1, 180, 3),
-		"replica count should be %d after 3 minutes", 1)
+		"replica count should be %d after 9 minutes", 1)
 
 	// Ensure nginx deployment is at min replica count
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicaCount, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicaCount)
+		"replica count should be %d after 9 minutes", minReplicaCount)
 
 	// test scaling
 	testActivation(t, kc)
diff --git a/tests/scalers/sumologic/sumologic_test.go b/tests/scalers/sumologic/sumologic_test.go
index 989851aca..e3d145f07 100644
--- a/tests/scalers/sumologic/sumologic_test.go
+++ b/tests/scalers/sumologic/sumologic_test.go
@@ -172,7 +172,7 @@ func TestSumologicScaler(t *testing.T) {
 
 	// Ensure deployment is at min replica count
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicaCount, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicaCount)
+		"replica count should be %d after 9 minutes", minReplicaCount)
 
 	// Test scaling
 	testActivation(t, kc)
diff --git a/tests/secret-providers/trigger_auth_bound_service_account_token/trigger_auth_bound_service_account_token_test.go b/tests/secret-providers/trigger_auth_bound_service_account_token/trigger_auth_bound_service_account_token_test.go
index 94a4dba01..0975f2cfa 100644
--- a/tests/secret-providers/trigger_auth_bound_service_account_token/trigger_auth_bound_service_account_token_test.go
+++ b/tests/secret-providers/trigger_auth_bound_service_account_token/trigger_auth_bound_service_account_token_test.go
@@ -344,7 +344,7 @@ func testScaleOut(t *testing.T, kc *kubernetes.Clientset, data templateData) {
 	KubectlReplaceWithTemplate(t, data, "updateMetricTemplate", updateMetricTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, maxReplicaCount, 60, maxReplicaCount),
-		"replica count should be %d after 3 minutes", maxReplicaCount)
+		"replica count should be %d after 1 minute", maxReplicaCount)
 }
 
 func testScaleIn(t *testing.T, kc *kubernetes.Clientset, data templateData) {
diff --git a/tests/sequential/datadog_dca/datadog_dca_test.go b/tests/sequential/datadog_dca/datadog_dca_test.go
index 210003fb0..c4cb0bf2f 100644
--- a/tests/sequential/datadog_dca/datadog_dca_test.go
+++ b/tests/sequential/datadog_dca/datadog_dca_test.go
@@ -356,7 +356,7 @@ func TestDatadogScalerDCA(t *testing.T) {
 	KubectlApplyWithTemplate(t, data, "scaledObjectTemplate", scaledObjectTemplate)
 
 	assert.True(t, WaitForDeploymentReplicaReadyCount(t, kc, deploymentName, testNamespace, minReplicaCount, 180, 3),
-		"replica count should be %d after 3 minutes", minReplicaCount)
+		"replica count should be %d after 9 minutes", minReplicaCount)
 
 	// test scaling
 	testActivation(t, kc, data)