tasks/format-code-task-000059/tests/test.patch

diff --git a/apis/datadoghq/v2alpha1/datadogagent_update_strategy_schema_test.go b/apis/datadoghq/v2alpha1/datadogagent_update_strategy_schema_test.go
new file mode 100644
index 00000000..482aa990
--- /dev/null
+++ b/apis/datadoghq/v2alpha1/datadogagent_update_strategy_schema_test.go
@@ -0,0 +1,115 @@
+package v2alpha1
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sigs.k8s.io/yaml"
+)
+
+func TestDatadogAgentOverrideUpdateStrategyIsExposedInCRDSchema(t *testing.T) {
+
+	crdPath := filepath.Join("..", "..", "..", "config", "crd", "bases", "v1", "datadoghq.com_datadogagents.yaml")
+	raw, err := os.ReadFile(crdPath)
+	require.NoError(t, err)
+
+	var crd map[string]interface{}
+	require.NoError(t, yaml.Unmarshal(raw, &crd))
+
+	var updateStrategySchema map[string]interface{}
+	for _, candidate := range findObjectProperties(crd, "updateStrategy") {
+		candidateProperties := properties(candidate)
+		rollingUpdate, hasRollingUpdate := candidateProperties["rollingUpdate"]
+		rollingProperties := properties(rollingUpdate)
+		if _, hasType := candidateProperties["type"]; hasType && hasRollingUpdate && rollingProperties["maxUnavailable"] != nil && rollingProperties["maxSurge"] != nil {
+			updateStrategySchema = candidate
+			break
+		}
+	}
+	require.NotNil(t, updateStrategySchema, "component override schema should expose updateStrategy with rollingUpdate limits")
+
+	strategyType, ok := properties(updateStrategySchema)["type"]
+	require.True(t, ok, "updateStrategy should expose a strategy type")
+	assert.Equal(t, "string", fieldString(strategyType, "type"))
+
+	rollingUpdate, ok := properties(updateStrategySchema)["rollingUpdate"]
+	require.True(t, ok, "updateStrategy should expose rollingUpdate limits")
+
+	rollingProperties := properties(rollingUpdate)
+	assertIntOrStringSchema(t, rollingProperties["maxUnavailable"], "maxUnavailable")
+	assertIntOrStringSchema(t, rollingProperties["maxSurge"], "maxSurge")
+}
+
+func findObjectProperties(node interface{}, property string) []map[string]interface{} {
+	switch value := node.(type) {
+	case map[string]interface{}:
+		var matches []map[string]interface{}
+		if props := properties(value); props != nil {
+			if found, ok := props[property].(map[string]interface{}); ok {
+				matches = append(matches, found)
+			}
+		}
+		for _, child := range value {
+			matches = append(matches, findObjectProperties(child, property)...)
+		}
+		return matches
+	case []interface{}:
+		var matches []map[string]interface{}
+		for _, child := range value {
+			matches = append(matches, findObjectProperties(child, property)...)
+		}
+		return matches
+	default:
+		return nil
+	}
+}
+
+func properties(schema interface{}) map[string]interface{} {
+	value, ok := schema.(map[string]interface{})
+	if !ok {
+		return nil
+	}
+	props, ok := value["properties"].(map[string]interface{})
+	if !ok {
+		return nil
+	}
+	return props
+}
+
+func assertIntOrStringSchema(t *testing.T, schema interface{}, field string) {
+	t.Helper()
+
+	value := requireMap(t, schema, field)
+
+	assert.Equal(t, true, value["x-kubernetes-int-or-string"], "%s should preserve Kubernetes IntOrString schema semantics", field)
+
+	branches, ok := value["anyOf"].([]interface{})
+	require.True(t, ok, "%s should allow integer and string branches", field)
+
+	seen := map[string]bool{}
+	for _, branch := range branches {
+		seen[fieldString(branch, "type")] = true
+	}
+	assert.True(t, seen["integer"], "%s should allow integer values", field)
+	assert.True(t, seen["string"], "%s should allow string values", field)
+}
+
+func requireMap(t *testing.T, value interface{}, name string) map[string]interface{} {
+	t.Helper()
+
+	result, ok := value.(map[string]interface{})
+	require.True(t, ok, "%s should be an object schema", name)
+	return result
+}
+
+func fieldString(value interface{}, field string) string {
+	object, ok := value.(map[string]interface{})
+	if !ok {
+		return ""
+	}
+	text, _ := object[field].(string)
+	return text
+}
diff --git a/controllers/datadogagent/override/daemonset_test.go b/controllers/datadogagent/override/daemonset_test.go
new file mode 100644
index 00000000..22511049
--- /dev/null
+++ b/controllers/datadogagent/override/daemonset_test.go
@@ -0,0 +1,96 @@
+package override
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/DataDog/datadog-operator/apis/datadoghq/v2alpha1"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	appsv1 "k8s.io/api/apps/v1"
+	"k8s.io/apimachinery/pkg/util/intstr"
+)
+
+func TestDaemonSetAppliesUpdateStrategyFromJSONOverride(t *testing.T) {
+	tests := []struct {
+		name                string
+		overrideJSON        string
+		expectedType        appsv1.DaemonSetUpdateStrategyType
+		expectedUnavailable *intstr.IntOrString
+		expectedSurge       *intstr.IntOrString
+	}{
+		{
+			name: "rolling update keeps percentage limits",
+			overrideJSON: `{
+				"updateStrategy": {
+					"type": "RollingUpdate",
+					"rollingUpdate": {
+						"maxUnavailable": "30%",
+						"maxSurge": "20%"
+					}
+				}
+			}`,
+			expectedType:        appsv1.RollingUpdateDaemonSetStrategyType,
+			expectedUnavailable: intOrStringPtr(intstr.FromString("30%")),
+			expectedSurge:       intOrStringPtr(intstr.FromString("20%")),
+		},
+		{
+			name: "rolling update keeps numeric limits",
+			overrideJSON: `{
+				"updateStrategy": {
+					"type": "RollingUpdate",
+					"rollingUpdate": {
+						"maxUnavailable": 3,
+						"maxSurge": 2
+					}
+				}
+			}`,
+			expectedType:        appsv1.RollingUpdateDaemonSetStrategyType,
+			expectedUnavailable: intOrStringPtr(intstr.FromInt(3)),
+			expectedSurge:       intOrStringPtr(intstr.FromInt(2)),
+		},
+		{
+			name: "non rolling strategy keeps the requested type",
+			overrideJSON: `{
+				"updateStrategy": {
+					"type": "OnDelete"
+				}
+			}`,
+			expectedType: appsv1.OnDeleteDaemonSetStrategyType,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			daemonSet := appsv1.DaemonSet{}
+			override := componentOverrideFromJSON(t, tt.overrideJSON)
+
+			DaemonSet(&daemonSet, &override)
+
+			assert.Equal(t, tt.expectedType, daemonSet.Spec.UpdateStrategy.Type)
+			if tt.expectedUnavailable != nil || tt.expectedSurge != nil {
+				require.NotNil(t, daemonSet.Spec.UpdateStrategy.RollingUpdate)
+			}
+			if tt.expectedUnavailable != nil {
+				require.NotNil(t, daemonSet.Spec.UpdateStrategy.RollingUpdate.MaxUnavailable)
+				assert.Equal(t, *tt.expectedUnavailable, *daemonSet.Spec.UpdateStrategy.RollingUpdate.MaxUnavailable)
+			}
+			if tt.expectedSurge != nil {
+				require.NotNil(t, daemonSet.Spec.UpdateStrategy.RollingUpdate.MaxSurge)
+				assert.Equal(t, *tt.expectedSurge, *daemonSet.Spec.UpdateStrategy.RollingUpdate.MaxSurge)
+			}
+		})
+	}
+}
+
+func componentOverrideFromJSON(t *testing.T, payload string) v2alpha1.DatadogAgentComponentOverride {
+	t.Helper()
+
+	var override v2alpha1.DatadogAgentComponentOverride
+	require.NoError(t, json.Unmarshal([]byte(payload), &override))
+	return override
+}
+
+func intOrStringPtr(value intstr.IntOrString) *intstr.IntOrString {
+	return &value
+}
diff --git a/controllers/datadogagent/override/deploymentspec_test.go b/controllers/datadogagent/override/deploymentspec_test.go
index 2d6a165a..5f4218a3 100644
--- a/controllers/datadogagent/override/deploymentspec_test.go
+++ b/controllers/datadogagent/override/deploymentspec_test.go
@@ -11,10 +11,84 @@ import (
 	"github.com/DataDog/datadog-operator/apis/datadoghq/v2alpha1"
 	apiutils "github.com/DataDog/datadog-operator/apis/utils"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	v1 "k8s.io/api/apps/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/intstr"
 )
 
+func TestDeploymentAppliesUpdateStrategyFromJSONOverride(t *testing.T) {
+	tests := []struct {
+		name                string
+		overrideJSON        string
+		expectedType        v1.DeploymentStrategyType
+		expectedUnavailable *intstr.IntOrString
+		expectedSurge       *intstr.IntOrString
+	}{
+		{
+			name: "rolling update keeps percentage limits",
+			overrideJSON: `{
+				"updateStrategy": {
+					"type": "RollingUpdate",
+					"rollingUpdate": {
+						"maxUnavailable": "25%",
+						"maxSurge": "15%"
+					}
+				}
+			}`,
+			expectedType:        v1.RollingUpdateDeploymentStrategyType,
+			expectedUnavailable: intOrStringPtr(intstr.FromString("25%")),
+			expectedSurge:       intOrStringPtr(intstr.FromString("15%")),
+		},
+		{
+			name: "rolling update keeps numeric limits",
+			overrideJSON: `{
+				"updateStrategy": {
+					"type": "RollingUpdate",
+					"rollingUpdate": {
+						"maxUnavailable": 1,
+						"maxSurge": 4
+					}
+				}
+			}`,
+			expectedType:        v1.RollingUpdateDeploymentStrategyType,
+			expectedUnavailable: intOrStringPtr(intstr.FromInt(1)),
+			expectedSurge:       intOrStringPtr(intstr.FromInt(4)),
+		},
+		{
+			name: "non rolling strategy keeps the requested type",
+			overrideJSON: `{
+				"updateStrategy": {
+					"type": "Recreate"
+				}
+			}`,
+			expectedType: v1.RecreateDeploymentStrategyType,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			deployment := v1.Deployment{}
+			override := componentOverrideFromJSON(t, tt.overrideJSON)
+
+			Deployment(&deployment, &override)
+
+			assert.Equal(t, tt.expectedType, deployment.Spec.Strategy.Type)
+			if tt.expectedUnavailable != nil || tt.expectedSurge != nil {
+				require.NotNil(t, deployment.Spec.Strategy.RollingUpdate)
+			}
+			if tt.expectedUnavailable != nil {
+				require.NotNil(t, deployment.Spec.Strategy.RollingUpdate.MaxUnavailable)
+				assert.Equal(t, *tt.expectedUnavailable, *deployment.Spec.Strategy.RollingUpdate.MaxUnavailable)
+			}
+			if tt.expectedSurge != nil {
+				require.NotNil(t, deployment.Spec.Strategy.RollingUpdate.MaxSurge)
+				assert.Equal(t, *tt.expectedSurge, *deployment.Spec.Strategy.RollingUpdate.MaxSurge)
+			}
+		})
+	}
+}
+
 func TestDeployment(t *testing.T) {
 	deployment := v1.Deployment{
 		ObjectMeta: metav1.ObjectMeta{
diff --git a/mimo_test_command.sh b/mimo_test_command.sh
new file mode 100755
--- /dev/null
+++ b/mimo_test_command.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+set -euo pipefail
+cd /testbed
+
+
+
+case "${1:-}" in
+  base)
+    go test ./controllers/datadogagent/override/ -run '^TestDeployment$' -v
+    ;;
+  new)
+    go test ./apis/datadoghq/v2alpha1 -run '^TestDatadogAgentOverrideUpdateStrategyIsExposedInCRDSchema$' -v
+    go test ./controllers/datadogagent/override/ -run '^(TestDaemonSetAppliesUpdateStrategyFromJSONOverride|TestDeploymentAppliesUpdateStrategyFromJSONOverride)$' -v
+    ;;
+  *)
+    echo "usage: $0 base|new"
+    exit 2
+    ;;
+esac