mirror of
https://github.com/stakater/Reloader.git
synced 2026-08-20 04:26:28 +00:00
1769 lines
52 KiB
Go
1769 lines
52 KiB
Go
package workload
|
|
|
|
import (
|
|
"testing"
|
|
|
|
argorolloutv1alpha1 "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1"
|
|
corev1 "k8s.io/api/core/v1"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
|
|
"github.com/stakater/Reloader/internal/pkg/testutil"
|
|
)
|
|
|
|
// testRolloutStrategyAnnotation is the annotation key used in tests for rollout strategy.
|
|
const testRolloutStrategyAnnotation = "reloader.stakater.com/rollout-strategy"
|
|
|
|
// addEnvVar adds an environment variable with a ConfigMapKeyRef or SecretKeyRef to a container.
|
|
func addEnvVarConfigMapRef(containers []corev1.Container, envName, configMapName, key string) {
|
|
if len(containers) > 0 {
|
|
containers[0].Env = append(containers[0].Env, corev1.EnvVar{
|
|
Name: envName,
|
|
ValueFrom: &corev1.EnvVarSource{
|
|
ConfigMapKeyRef: &corev1.ConfigMapKeySelector{
|
|
LocalObjectReference: corev1.LocalObjectReference{Name: configMapName},
|
|
Key: key,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
}
|
|
|
|
func addEnvVarSecretRef(containers []corev1.Container, envName, secretName, key string) {
|
|
if len(containers) > 0 {
|
|
containers[0].Env = append(containers[0].Env, corev1.EnvVar{
|
|
Name: envName,
|
|
ValueFrom: &corev1.EnvVarSource{
|
|
SecretKeyRef: &corev1.SecretKeySelector{
|
|
LocalObjectReference: corev1.LocalObjectReference{Name: secretName},
|
|
Key: key,
|
|
},
|
|
},
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_BasicGetters(t *testing.T) {
|
|
deploy := testutil.NewDeployment("test-deploy", "test-ns", map[string]string{"key": "value"})
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
if w.Kind() != KindDeployment {
|
|
t.Errorf("Kind() = %v, want %v", w.Kind(), KindDeployment)
|
|
}
|
|
if w.GetName() != "test-deploy" {
|
|
t.Errorf("GetName() = %v, want test-deploy", w.GetName())
|
|
}
|
|
if w.GetNamespace() != "test-ns" {
|
|
t.Errorf("GetNamespace() = %v, want test-ns", w.GetNamespace())
|
|
}
|
|
if w.GetAnnotations()["key"] != "value" {
|
|
t.Errorf("GetAnnotations()[key] = %v, want value", w.GetAnnotations()["key"])
|
|
}
|
|
if w.GetObject() != deploy {
|
|
t.Error("GetObject() should return the underlying deployment")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_PodTemplateAnnotations(t *testing.T) {
|
|
deploy := testutil.NewDeployment("test", "default", nil)
|
|
deploy.Spec.Template.Annotations["existing"] = "annotation"
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
// Test get
|
|
annotations := w.GetPodTemplateAnnotations()
|
|
if annotations["existing"] != "annotation" {
|
|
t.Errorf("GetPodTemplateAnnotations()[existing] = %v, want annotation", annotations["existing"])
|
|
}
|
|
|
|
// Test set
|
|
w.SetPodTemplateAnnotation("new-key", "new-value")
|
|
if w.GetPodTemplateAnnotations()["new-key"] != "new-value" {
|
|
t.Error("SetPodTemplateAnnotation should add new annotation")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_PodTemplateAnnotations_NilInit(t *testing.T) {
|
|
deploy := testutil.NewDeployment("test", "default", nil)
|
|
deploy.Spec.Template.Annotations = nil
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
// Should initialize nil map
|
|
annotations := w.GetPodTemplateAnnotations()
|
|
if annotations == nil {
|
|
t.Error("GetPodTemplateAnnotations should initialize nil map")
|
|
}
|
|
|
|
// Should work with nil initial map
|
|
w.SetPodTemplateAnnotation("key", "value")
|
|
if w.GetPodTemplateAnnotations()["key"] != "value" {
|
|
t.Error("SetPodTemplateAnnotation should work with nil initial map")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_Containers(t *testing.T) {
|
|
deploy := testutil.NewDeployment("test", "default", nil)
|
|
deploy.Spec.Template.Spec.InitContainers = []corev1.Container{{Name: "init", Image: "busybox"}}
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
// Test get containers
|
|
containers := w.GetContainers()
|
|
if len(containers) != 1 || containers[0].Name != "main" {
|
|
t.Errorf("GetContainers() = %v, want [main]", containers)
|
|
}
|
|
|
|
// Test get init containers
|
|
initContainers := w.GetInitContainers()
|
|
if len(initContainers) != 1 || initContainers[0].Name != "init" {
|
|
t.Errorf("GetInitContainers() = %v, want [init]", initContainers)
|
|
}
|
|
|
|
// Test set containers
|
|
newContainers := []corev1.Container{{Name: "new-main", Image: "alpine"}}
|
|
w.SetContainers(newContainers)
|
|
if w.GetContainers()[0].Name != "new-main" {
|
|
t.Error("SetContainers should update containers")
|
|
}
|
|
|
|
// Test set init containers
|
|
newInitContainers := []corev1.Container{{Name: "new-init", Image: "alpine"}}
|
|
w.SetInitContainers(newInitContainers)
|
|
if w.GetInitContainers()[0].Name != "new-init" {
|
|
t.Error("SetInitContainers should update init containers")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_Volumes(t *testing.T) {
|
|
deploy := testutil.NewDeployment("test", "default", nil)
|
|
deploy.Spec.Template.Spec.Volumes = []corev1.Volume{
|
|
{Name: "config-vol"},
|
|
{Name: "secret-vol"},
|
|
}
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
volumes := w.GetVolumes()
|
|
if len(volumes) != 2 {
|
|
t.Errorf("GetVolumes() length = %d, want 2", len(volumes))
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_UsesConfigMap_Volume(t *testing.T) {
|
|
deploy := testutil.NewDeploymentWithVolume("test", "default", "my-config", "")
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
if !w.UsesConfigMap("my-config") {
|
|
t.Error("UsesConfigMap should return true for ConfigMap volume")
|
|
}
|
|
if w.UsesConfigMap("other-config") {
|
|
t.Error("UsesConfigMap should return false for non-existent ConfigMap")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_UsesConfigMap_ProjectedVolume(t *testing.T) {
|
|
deploy := testutil.NewDeploymentWithProjectedVolume("test", "default", "projected-config", "")
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
if !w.UsesConfigMap("projected-config") {
|
|
t.Error("UsesConfigMap should return true for projected ConfigMap volume")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_UsesConfigMap_EnvFrom(t *testing.T) {
|
|
deploy := testutil.NewDeploymentWithEnvFrom("test", "default", "env-config", "")
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
if !w.UsesConfigMap("env-config") {
|
|
t.Error("UsesConfigMap should return true for envFrom ConfigMap")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_UsesConfigMap_EnvVar(t *testing.T) {
|
|
deploy := testutil.NewDeployment("test", "default", nil)
|
|
addEnvVarConfigMapRef(deploy.Spec.Template.Spec.Containers, "CONFIG_VALUE", "var-config", "some-key")
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
if !w.UsesConfigMap("var-config") {
|
|
t.Error("UsesConfigMap should return true for env var ConfigMapKeyRef")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_UsesConfigMap_InitContainer(t *testing.T) {
|
|
deploy := testutil.NewDeployment("test", "default", nil)
|
|
deploy.Spec.Template.Spec.InitContainers = []corev1.Container{
|
|
{
|
|
Name: "init",
|
|
EnvFrom: []corev1.EnvFromSource{
|
|
{
|
|
ConfigMapRef: &corev1.ConfigMapEnvSource{
|
|
LocalObjectReference: corev1.LocalObjectReference{Name: "init-config"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
if !w.UsesConfigMap("init-config") {
|
|
t.Error("UsesConfigMap should return true for init container ConfigMap")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_UsesSecret_Volume(t *testing.T) {
|
|
deploy := testutil.NewDeploymentWithVolume("test", "default", "", "my-secret")
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
if !w.UsesSecret("my-secret") {
|
|
t.Error("UsesSecret should return true for Secret volume")
|
|
}
|
|
if w.UsesSecret("other-secret") {
|
|
t.Error("UsesSecret should return false for non-existent Secret")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_UsesSecret_ProjectedVolume(t *testing.T) {
|
|
deploy := testutil.NewDeploymentWithProjectedVolume("test", "default", "", "projected-secret")
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
if !w.UsesSecret("projected-secret") {
|
|
t.Error("UsesSecret should return true for projected Secret volume")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_UsesSecret_EnvFrom(t *testing.T) {
|
|
deploy := testutil.NewDeploymentWithEnvFrom("test", "default", "", "env-secret")
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
if !w.UsesSecret("env-secret") {
|
|
t.Error("UsesSecret should return true for envFrom Secret")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_UsesSecret_EnvVar(t *testing.T) {
|
|
deploy := testutil.NewDeployment("test", "default", nil)
|
|
addEnvVarSecretRef(deploy.Spec.Template.Spec.Containers, "SECRET_VALUE", "var-secret", "some-key")
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
if !w.UsesSecret("var-secret") {
|
|
t.Error("UsesSecret should return true for env var SecretKeyRef")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_UsesSecret_InitContainer(t *testing.T) {
|
|
deploy := testutil.NewDeployment("test", "default", nil)
|
|
deploy.Spec.Template.Spec.InitContainers = []corev1.Container{
|
|
{
|
|
Name: "init",
|
|
EnvFrom: []corev1.EnvFromSource{
|
|
{
|
|
SecretRef: &corev1.SecretEnvSource{
|
|
LocalObjectReference: corev1.LocalObjectReference{Name: "init-secret"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
if !w.UsesSecret("init-secret") {
|
|
t.Error("UsesSecret should return true for init container Secret")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_GetEnvFromSources(t *testing.T) {
|
|
deploy := testutil.NewDeployment("test", "default", nil)
|
|
deploy.Spec.Template.Spec.Containers = []corev1.Container{
|
|
{
|
|
Name: "main",
|
|
EnvFrom: []corev1.EnvFromSource{{ConfigMapRef: &corev1.ConfigMapEnvSource{LocalObjectReference: corev1.LocalObjectReference{Name: "cm1"}}}},
|
|
},
|
|
{
|
|
Name: "sidecar",
|
|
EnvFrom: []corev1.EnvFromSource{{SecretRef: &corev1.SecretEnvSource{LocalObjectReference: corev1.LocalObjectReference{Name: "secret1"}}}},
|
|
},
|
|
}
|
|
deploy.Spec.Template.Spec.InitContainers = []corev1.Container{
|
|
{
|
|
Name: "init",
|
|
EnvFrom: []corev1.EnvFromSource{{ConfigMapRef: &corev1.ConfigMapEnvSource{LocalObjectReference: corev1.LocalObjectReference{Name: "init-cm"}}}},
|
|
},
|
|
}
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
sources := w.GetEnvFromSources()
|
|
if len(sources) != 3 {
|
|
t.Errorf("GetEnvFromSources() returned %d sources, want 3", len(sources))
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_DeepCopy(t *testing.T) {
|
|
deploy := testutil.NewDeployment("test", "default", nil)
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
copy := w.DeepCopy()
|
|
|
|
// Modify original
|
|
w.SetPodTemplateAnnotation("modified", "true")
|
|
|
|
// Copy should not be affected
|
|
copyAnnotations := copy.GetPodTemplateAnnotations()
|
|
if copyAnnotations["modified"] == "true" {
|
|
t.Error("DeepCopy should create independent copy")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_GetOwnerReferences(t *testing.T) {
|
|
deploy := testutil.NewDeployment("test", "default", nil)
|
|
deploy.OwnerReferences = []metav1.OwnerReference{
|
|
{APIVersion: "apps/v1", Kind: "ReplicaSet", Name: "test-rs"},
|
|
}
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
refs := w.GetOwnerReferences()
|
|
if len(refs) != 1 || refs[0].Name != "test-rs" {
|
|
t.Errorf("GetOwnerReferences() = %v, want owner ref to test-rs", refs)
|
|
}
|
|
}
|
|
|
|
// DaemonSet tests
|
|
func TestDaemonSetWorkload_BasicGetters(t *testing.T) {
|
|
ds := testutil.NewDaemonSet("test-ds", "test-ns", map[string]string{"key": "value"})
|
|
|
|
w := NewDaemonSetWorkload(ds)
|
|
|
|
if w.Kind() != KindDaemonSet {
|
|
t.Errorf("Kind() = %v, want %v", w.Kind(), KindDaemonSet)
|
|
}
|
|
if w.GetName() != "test-ds" {
|
|
t.Errorf("GetName() = %v, want test-ds", w.GetName())
|
|
}
|
|
if w.GetNamespace() != "test-ns" {
|
|
t.Errorf("GetNamespace() = %v, want test-ns", w.GetNamespace())
|
|
}
|
|
if w.GetAnnotations()["key"] != "value" {
|
|
t.Errorf("GetAnnotations()[key] = %v, want value", w.GetAnnotations()["key"])
|
|
}
|
|
if w.GetObject() != ds {
|
|
t.Error("GetObject() should return the underlying daemonset")
|
|
}
|
|
}
|
|
|
|
func TestDaemonSetWorkload_PodTemplateAnnotations(t *testing.T) {
|
|
ds := testutil.NewDaemonSet("test", "default", nil)
|
|
ds.Spec.Template.Annotations["existing"] = "annotation"
|
|
|
|
w := NewDaemonSetWorkload(ds)
|
|
|
|
annotations := w.GetPodTemplateAnnotations()
|
|
if annotations["existing"] != "annotation" {
|
|
t.Errorf("GetPodTemplateAnnotations()[existing] = %v, want annotation", annotations["existing"])
|
|
}
|
|
|
|
w.SetPodTemplateAnnotation("new-key", "new-value")
|
|
if w.GetPodTemplateAnnotations()["new-key"] != "new-value" {
|
|
t.Error("SetPodTemplateAnnotation should add new annotation")
|
|
}
|
|
}
|
|
|
|
func TestDaemonSetWorkload_PodTemplateAnnotations_NilInit(t *testing.T) {
|
|
ds := testutil.NewDaemonSet("test", "default", nil)
|
|
ds.Spec.Template.Annotations = nil
|
|
|
|
w := NewDaemonSetWorkload(ds)
|
|
|
|
annotations := w.GetPodTemplateAnnotations()
|
|
if annotations == nil {
|
|
t.Error("GetPodTemplateAnnotations should initialize nil map")
|
|
}
|
|
|
|
w.SetPodTemplateAnnotation("key", "value")
|
|
if w.GetPodTemplateAnnotations()["key"] != "value" {
|
|
t.Error("SetPodTemplateAnnotation should work with nil initial map")
|
|
}
|
|
}
|
|
|
|
func TestDaemonSetWorkload_Containers(t *testing.T) {
|
|
ds := testutil.NewDaemonSet("test", "default", nil)
|
|
ds.Spec.Template.Spec.InitContainers = []corev1.Container{{Name: "init", Image: "busybox"}}
|
|
|
|
w := NewDaemonSetWorkload(ds)
|
|
|
|
containers := w.GetContainers()
|
|
if len(containers) != 1 || containers[0].Name != "main" {
|
|
t.Errorf("GetContainers() = %v, want [main]", containers)
|
|
}
|
|
|
|
initContainers := w.GetInitContainers()
|
|
if len(initContainers) != 1 || initContainers[0].Name != "init" {
|
|
t.Errorf("GetInitContainers() = %v, want [init]", initContainers)
|
|
}
|
|
|
|
newContainers := []corev1.Container{{Name: "new-main", Image: "alpine"}}
|
|
w.SetContainers(newContainers)
|
|
if w.GetContainers()[0].Name != "new-main" {
|
|
t.Error("SetContainers should update containers")
|
|
}
|
|
|
|
newInitContainers := []corev1.Container{{Name: "new-init", Image: "alpine"}}
|
|
w.SetInitContainers(newInitContainers)
|
|
if w.GetInitContainers()[0].Name != "new-init" {
|
|
t.Error("SetInitContainers should update init containers")
|
|
}
|
|
}
|
|
|
|
func TestDaemonSetWorkload_Volumes(t *testing.T) {
|
|
ds := testutil.NewDaemonSet("test", "default", nil)
|
|
ds.Spec.Template.Spec.Volumes = []corev1.Volume{
|
|
{Name: "config-vol"},
|
|
{Name: "secret-vol"},
|
|
}
|
|
|
|
w := NewDaemonSetWorkload(ds)
|
|
|
|
volumes := w.GetVolumes()
|
|
if len(volumes) != 2 {
|
|
t.Errorf("GetVolumes() length = %d, want 2", len(volumes))
|
|
}
|
|
}
|
|
|
|
func TestDaemonSetWorkload_UsesConfigMap(t *testing.T) {
|
|
ds := testutil.NewDaemonSet("test", "default", nil)
|
|
ds.Spec.Template.Spec.Volumes = []corev1.Volume{
|
|
{
|
|
Name: "config-vol",
|
|
VolumeSource: corev1.VolumeSource{
|
|
ConfigMap: &corev1.ConfigMapVolumeSource{
|
|
LocalObjectReference: corev1.LocalObjectReference{Name: "ds-config"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewDaemonSetWorkload(ds)
|
|
|
|
if !w.UsesConfigMap("ds-config") {
|
|
t.Error("DaemonSet UsesConfigMap should return true for ConfigMap volume")
|
|
}
|
|
if w.UsesConfigMap("other-config") {
|
|
t.Error("UsesConfigMap should return false for non-existent ConfigMap")
|
|
}
|
|
}
|
|
|
|
func TestDaemonSetWorkload_UsesConfigMap_EnvFrom(t *testing.T) {
|
|
ds := testutil.NewDaemonSet("test", "default", nil)
|
|
ds.Spec.Template.Spec.Containers[0].EnvFrom = []corev1.EnvFromSource{
|
|
{ConfigMapRef: &corev1.ConfigMapEnvSource{LocalObjectReference: corev1.LocalObjectReference{Name: "ds-env-config"}}},
|
|
}
|
|
|
|
w := NewDaemonSetWorkload(ds)
|
|
|
|
if !w.UsesConfigMap("ds-env-config") {
|
|
t.Error("DaemonSet UsesConfigMap should return true for envFrom ConfigMap")
|
|
}
|
|
}
|
|
|
|
func TestDaemonSetWorkload_UsesSecret(t *testing.T) {
|
|
ds := testutil.NewDaemonSet("test", "default", nil)
|
|
ds.Spec.Template.Spec.Volumes = []corev1.Volume{
|
|
{
|
|
Name: "secret-vol",
|
|
VolumeSource: corev1.VolumeSource{
|
|
Secret: &corev1.SecretVolumeSource{SecretName: "ds-secret"},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewDaemonSetWorkload(ds)
|
|
|
|
if !w.UsesSecret("ds-secret") {
|
|
t.Error("DaemonSet UsesSecret should return true for Secret volume")
|
|
}
|
|
if w.UsesSecret("other-secret") {
|
|
t.Error("UsesSecret should return false for non-existent Secret")
|
|
}
|
|
}
|
|
|
|
func TestDaemonSetWorkload_GetEnvFromSources(t *testing.T) {
|
|
ds := testutil.NewDaemonSet("test", "default", nil)
|
|
ds.Spec.Template.Spec.Containers[0].EnvFrom = []corev1.EnvFromSource{
|
|
{ConfigMapRef: &corev1.ConfigMapEnvSource{LocalObjectReference: corev1.LocalObjectReference{Name: "cm1"}}},
|
|
}
|
|
ds.Spec.Template.Spec.InitContainers = []corev1.Container{
|
|
{
|
|
Name: "init",
|
|
EnvFrom: []corev1.EnvFromSource{{SecretRef: &corev1.SecretEnvSource{LocalObjectReference: corev1.LocalObjectReference{Name: "secret1"}}}},
|
|
},
|
|
}
|
|
|
|
w := NewDaemonSetWorkload(ds)
|
|
|
|
sources := w.GetEnvFromSources()
|
|
if len(sources) != 2 {
|
|
t.Errorf("GetEnvFromSources() returned %d sources, want 2", len(sources))
|
|
}
|
|
}
|
|
|
|
func TestDaemonSetWorkload_DeepCopy(t *testing.T) {
|
|
ds := testutil.NewDaemonSet("test", "default", nil)
|
|
|
|
w := NewDaemonSetWorkload(ds)
|
|
copy := w.DeepCopy()
|
|
|
|
w.SetPodTemplateAnnotation("modified", "true")
|
|
|
|
copyAnnotations := copy.GetPodTemplateAnnotations()
|
|
if copyAnnotations["modified"] == "true" {
|
|
t.Error("DeepCopy should create independent copy")
|
|
}
|
|
}
|
|
|
|
func TestDaemonSetWorkload_GetOwnerReferences(t *testing.T) {
|
|
ds := testutil.NewDaemonSet("test", "default", nil)
|
|
ds.OwnerReferences = []metav1.OwnerReference{
|
|
{APIVersion: "apps/v1", Kind: "DaemonSet", Name: "test-owner"},
|
|
}
|
|
|
|
w := NewDaemonSetWorkload(ds)
|
|
|
|
refs := w.GetOwnerReferences()
|
|
if len(refs) != 1 || refs[0].Name != "test-owner" {
|
|
t.Errorf("GetOwnerReferences() = %v, want owner ref to test-owner", refs)
|
|
}
|
|
}
|
|
|
|
// StatefulSet tests
|
|
func TestStatefulSetWorkload_BasicGetters(t *testing.T) {
|
|
sts := testutil.NewStatefulSet("test-sts", "test-ns", map[string]string{"key": "value"})
|
|
|
|
w := NewStatefulSetWorkload(sts)
|
|
|
|
if w.Kind() != KindStatefulSet {
|
|
t.Errorf("Kind() = %v, want %v", w.Kind(), KindStatefulSet)
|
|
}
|
|
if w.GetName() != "test-sts" {
|
|
t.Errorf("GetName() = %v, want test-sts", w.GetName())
|
|
}
|
|
if w.GetNamespace() != "test-ns" {
|
|
t.Errorf("GetNamespace() = %v, want test-ns", w.GetNamespace())
|
|
}
|
|
if w.GetAnnotations()["key"] != "value" {
|
|
t.Errorf("GetAnnotations()[key] = %v, want value", w.GetAnnotations()["key"])
|
|
}
|
|
if w.GetObject() != sts {
|
|
t.Error("GetObject() should return the underlying statefulset")
|
|
}
|
|
}
|
|
|
|
func TestStatefulSetWorkload_PodTemplateAnnotations(t *testing.T) {
|
|
sts := testutil.NewStatefulSet("test", "default", nil)
|
|
sts.Spec.Template.Annotations["existing"] = "annotation"
|
|
|
|
w := NewStatefulSetWorkload(sts)
|
|
|
|
annotations := w.GetPodTemplateAnnotations()
|
|
if annotations["existing"] != "annotation" {
|
|
t.Errorf("GetPodTemplateAnnotations()[existing] = %v, want annotation", annotations["existing"])
|
|
}
|
|
|
|
w.SetPodTemplateAnnotation("new-key", "new-value")
|
|
if w.GetPodTemplateAnnotations()["new-key"] != "new-value" {
|
|
t.Error("SetPodTemplateAnnotation should add new annotation")
|
|
}
|
|
}
|
|
|
|
func TestStatefulSetWorkload_PodTemplateAnnotations_NilInit(t *testing.T) {
|
|
sts := testutil.NewStatefulSet("test", "default", nil)
|
|
sts.Spec.Template.Annotations = nil
|
|
|
|
w := NewStatefulSetWorkload(sts)
|
|
|
|
annotations := w.GetPodTemplateAnnotations()
|
|
if annotations == nil {
|
|
t.Error("GetPodTemplateAnnotations should initialize nil map")
|
|
}
|
|
|
|
w.SetPodTemplateAnnotation("key", "value")
|
|
if w.GetPodTemplateAnnotations()["key"] != "value" {
|
|
t.Error("SetPodTemplateAnnotation should work with nil initial map")
|
|
}
|
|
}
|
|
|
|
func TestStatefulSetWorkload_Containers(t *testing.T) {
|
|
sts := testutil.NewStatefulSet("test", "default", nil)
|
|
sts.Spec.Template.Spec.InitContainers = []corev1.Container{{Name: "init", Image: "busybox"}}
|
|
|
|
w := NewStatefulSetWorkload(sts)
|
|
|
|
containers := w.GetContainers()
|
|
if len(containers) != 1 || containers[0].Name != "main" {
|
|
t.Errorf("GetContainers() = %v, want [main]", containers)
|
|
}
|
|
|
|
initContainers := w.GetInitContainers()
|
|
if len(initContainers) != 1 || initContainers[0].Name != "init" {
|
|
t.Errorf("GetInitContainers() = %v, want [init]", initContainers)
|
|
}
|
|
|
|
newContainers := []corev1.Container{{Name: "new-main", Image: "alpine"}}
|
|
w.SetContainers(newContainers)
|
|
if w.GetContainers()[0].Name != "new-main" {
|
|
t.Error("SetContainers should update containers")
|
|
}
|
|
|
|
newInitContainers := []corev1.Container{{Name: "new-init", Image: "alpine"}}
|
|
w.SetInitContainers(newInitContainers)
|
|
if w.GetInitContainers()[0].Name != "new-init" {
|
|
t.Error("SetInitContainers should update init containers")
|
|
}
|
|
}
|
|
|
|
func TestStatefulSetWorkload_Volumes(t *testing.T) {
|
|
sts := testutil.NewStatefulSet("test", "default", nil)
|
|
sts.Spec.Template.Spec.Volumes = []corev1.Volume{
|
|
{Name: "config-vol"},
|
|
{Name: "secret-vol"},
|
|
}
|
|
|
|
w := NewStatefulSetWorkload(sts)
|
|
|
|
volumes := w.GetVolumes()
|
|
if len(volumes) != 2 {
|
|
t.Errorf("GetVolumes() length = %d, want 2", len(volumes))
|
|
}
|
|
}
|
|
|
|
func TestStatefulSetWorkload_UsesConfigMap(t *testing.T) {
|
|
sts := testutil.NewStatefulSet("test", "default", nil)
|
|
sts.Spec.Template.Spec.Volumes = []corev1.Volume{
|
|
{
|
|
Name: "config-vol",
|
|
VolumeSource: corev1.VolumeSource{
|
|
ConfigMap: &corev1.ConfigMapVolumeSource{
|
|
LocalObjectReference: corev1.LocalObjectReference{Name: "sts-config"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewStatefulSetWorkload(sts)
|
|
|
|
if !w.UsesConfigMap("sts-config") {
|
|
t.Error("StatefulSet UsesConfigMap should return true for ConfigMap volume")
|
|
}
|
|
if w.UsesConfigMap("other-config") {
|
|
t.Error("UsesConfigMap should return false for non-existent ConfigMap")
|
|
}
|
|
}
|
|
|
|
func TestStatefulSetWorkload_UsesConfigMap_EnvFrom(t *testing.T) {
|
|
sts := testutil.NewStatefulSet("test", "default", nil)
|
|
sts.Spec.Template.Spec.Containers[0].EnvFrom = []corev1.EnvFromSource{
|
|
{ConfigMapRef: &corev1.ConfigMapEnvSource{LocalObjectReference: corev1.LocalObjectReference{Name: "sts-env-config"}}},
|
|
}
|
|
|
|
w := NewStatefulSetWorkload(sts)
|
|
|
|
if !w.UsesConfigMap("sts-env-config") {
|
|
t.Error("StatefulSet UsesConfigMap should return true for envFrom ConfigMap")
|
|
}
|
|
}
|
|
|
|
func TestStatefulSetWorkload_UsesSecret(t *testing.T) {
|
|
sts := testutil.NewStatefulSet("test", "default", nil)
|
|
sts.Spec.Template.Spec.Volumes = []corev1.Volume{
|
|
{
|
|
Name: "secret-vol",
|
|
VolumeSource: corev1.VolumeSource{
|
|
Secret: &corev1.SecretVolumeSource{SecretName: "sts-secret"},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewStatefulSetWorkload(sts)
|
|
|
|
if !w.UsesSecret("sts-secret") {
|
|
t.Error("StatefulSet UsesSecret should return true for Secret volume")
|
|
}
|
|
if w.UsesSecret("other-secret") {
|
|
t.Error("UsesSecret should return false for non-existent Secret")
|
|
}
|
|
}
|
|
|
|
func TestStatefulSetWorkload_UsesSecret_EnvFrom(t *testing.T) {
|
|
sts := testutil.NewStatefulSet("test", "default", nil)
|
|
sts.Spec.Template.Spec.Containers[0].EnvFrom = []corev1.EnvFromSource{
|
|
{SecretRef: &corev1.SecretEnvSource{LocalObjectReference: corev1.LocalObjectReference{Name: "sts-env-secret"}}},
|
|
}
|
|
|
|
w := NewStatefulSetWorkload(sts)
|
|
|
|
if !w.UsesSecret("sts-env-secret") {
|
|
t.Error("StatefulSet UsesSecret should return true for envFrom Secret")
|
|
}
|
|
}
|
|
|
|
func TestStatefulSetWorkload_GetEnvFromSources(t *testing.T) {
|
|
sts := testutil.NewStatefulSet("test", "default", nil)
|
|
sts.Spec.Template.Spec.Containers[0].EnvFrom = []corev1.EnvFromSource{
|
|
{ConfigMapRef: &corev1.ConfigMapEnvSource{LocalObjectReference: corev1.LocalObjectReference{Name: "cm1"}}},
|
|
}
|
|
sts.Spec.Template.Spec.InitContainers = []corev1.Container{
|
|
{
|
|
Name: "init",
|
|
EnvFrom: []corev1.EnvFromSource{{SecretRef: &corev1.SecretEnvSource{LocalObjectReference: corev1.LocalObjectReference{Name: "secret1"}}}},
|
|
},
|
|
}
|
|
|
|
w := NewStatefulSetWorkload(sts)
|
|
|
|
sources := w.GetEnvFromSources()
|
|
if len(sources) != 2 {
|
|
t.Errorf("GetEnvFromSources() returned %d sources, want 2", len(sources))
|
|
}
|
|
}
|
|
|
|
func TestStatefulSetWorkload_DeepCopy(t *testing.T) {
|
|
sts := testutil.NewStatefulSet("test", "default", nil)
|
|
|
|
w := NewStatefulSetWorkload(sts)
|
|
copy := w.DeepCopy()
|
|
|
|
w.SetPodTemplateAnnotation("modified", "true")
|
|
|
|
copyAnnotations := copy.GetPodTemplateAnnotations()
|
|
if copyAnnotations["modified"] == "true" {
|
|
t.Error("DeepCopy should create independent copy")
|
|
}
|
|
}
|
|
|
|
func TestStatefulSetWorkload_GetOwnerReferences(t *testing.T) {
|
|
sts := testutil.NewStatefulSet("test", "default", nil)
|
|
sts.OwnerReferences = []metav1.OwnerReference{
|
|
{APIVersion: "apps/v1", Kind: "StatefulSet", Name: "test-owner"},
|
|
}
|
|
|
|
w := NewStatefulSetWorkload(sts)
|
|
|
|
refs := w.GetOwnerReferences()
|
|
if len(refs) != 1 || refs[0].Name != "test-owner" {
|
|
t.Errorf("GetOwnerReferences() = %v, want owner ref to test-owner", refs)
|
|
}
|
|
}
|
|
|
|
// Test that workloads implement the interface
|
|
func TestWorkloadInterface(t *testing.T) {
|
|
var _ Workload = (*DeploymentWorkload)(nil)
|
|
var _ Workload = (*DaemonSetWorkload)(nil)
|
|
var _ Workload = (*StatefulSetWorkload)(nil)
|
|
var _ Workload = (*RolloutWorkload)(nil)
|
|
}
|
|
|
|
// RolloutWorkload tests
|
|
func TestRolloutWorkload_BasicGetters(t *testing.T) {
|
|
rollout := &argorolloutv1alpha1.Rollout{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "test-rollout",
|
|
Namespace: "test-ns",
|
|
Annotations: map[string]string{
|
|
"key": "value",
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewRolloutWorkload(rollout, testRolloutStrategyAnnotation)
|
|
|
|
if w.Kind() != KindArgoRollout {
|
|
t.Errorf("Kind() = %v, want %v", w.Kind(), KindArgoRollout)
|
|
}
|
|
if w.GetName() != "test-rollout" {
|
|
t.Errorf("GetName() = %v, want test-rollout", w.GetName())
|
|
}
|
|
if w.GetNamespace() != "test-ns" {
|
|
t.Errorf("GetNamespace() = %v, want test-ns", w.GetNamespace())
|
|
}
|
|
if w.GetAnnotations()["key"] != "value" {
|
|
t.Errorf("GetAnnotations()[key] = %v, want value", w.GetAnnotations()["key"])
|
|
}
|
|
if w.GetObject() != rollout {
|
|
t.Error("GetObject() should return the underlying rollout")
|
|
}
|
|
}
|
|
|
|
func TestRolloutWorkload_PodTemplateAnnotations(t *testing.T) {
|
|
rollout := &argorolloutv1alpha1.Rollout{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test"},
|
|
Spec: argorolloutv1alpha1.RolloutSpec{
|
|
Template: corev1.PodTemplateSpec{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Annotations: map[string]string{
|
|
"existing": "annotation",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewRolloutWorkload(rollout, testRolloutStrategyAnnotation)
|
|
|
|
// Test get
|
|
annotations := w.GetPodTemplateAnnotations()
|
|
if annotations["existing"] != "annotation" {
|
|
t.Errorf("GetPodTemplateAnnotations()[existing] = %v, want annotation", annotations["existing"])
|
|
}
|
|
|
|
// Test set
|
|
w.SetPodTemplateAnnotation("new-key", "new-value")
|
|
if w.GetPodTemplateAnnotations()["new-key"] != "new-value" {
|
|
t.Error("SetPodTemplateAnnotation should add new annotation")
|
|
}
|
|
}
|
|
|
|
func TestRolloutWorkload_GetStrategy_Default(t *testing.T) {
|
|
rollout := &argorolloutv1alpha1.Rollout{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test"},
|
|
}
|
|
|
|
w := NewRolloutWorkload(rollout, testRolloutStrategyAnnotation)
|
|
|
|
if w.GetStrategy() != RolloutStrategyRollout {
|
|
t.Errorf("GetStrategy() = %v, want %v (default)", w.GetStrategy(), RolloutStrategyRollout)
|
|
}
|
|
}
|
|
|
|
func TestRolloutWorkload_GetStrategy_Restart(t *testing.T) {
|
|
rollout := &argorolloutv1alpha1.Rollout{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "test",
|
|
Annotations: map[string]string{
|
|
testRolloutStrategyAnnotation: "restart",
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewRolloutWorkload(rollout, testRolloutStrategyAnnotation)
|
|
|
|
if w.GetStrategy() != RolloutStrategyRestart {
|
|
t.Errorf("GetStrategy() = %v, want %v", w.GetStrategy(), RolloutStrategyRestart)
|
|
}
|
|
}
|
|
|
|
func TestRolloutWorkload_UsesConfigMap_Volume(t *testing.T) {
|
|
rollout := &argorolloutv1alpha1.Rollout{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test"},
|
|
Spec: argorolloutv1alpha1.RolloutSpec{
|
|
Template: corev1.PodTemplateSpec{
|
|
Spec: corev1.PodSpec{
|
|
Volumes: []corev1.Volume{
|
|
{
|
|
Name: "config-vol",
|
|
VolumeSource: corev1.VolumeSource{
|
|
ConfigMap: &corev1.ConfigMapVolumeSource{
|
|
LocalObjectReference: corev1.LocalObjectReference{
|
|
Name: "rollout-config",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewRolloutWorkload(rollout, testRolloutStrategyAnnotation)
|
|
|
|
if !w.UsesConfigMap("rollout-config") {
|
|
t.Error("Rollout UsesConfigMap should return true for ConfigMap volume")
|
|
}
|
|
if w.UsesConfigMap("other-config") {
|
|
t.Error("Rollout UsesConfigMap should return false for non-existent ConfigMap")
|
|
}
|
|
}
|
|
|
|
func TestRolloutWorkload_UsesSecret_EnvFrom(t *testing.T) {
|
|
rollout := &argorolloutv1alpha1.Rollout{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test"},
|
|
Spec: argorolloutv1alpha1.RolloutSpec{
|
|
Template: corev1.PodTemplateSpec{
|
|
Spec: corev1.PodSpec{
|
|
Containers: []corev1.Container{
|
|
{
|
|
Name: "main",
|
|
EnvFrom: []corev1.EnvFromSource{
|
|
{
|
|
SecretRef: &corev1.SecretEnvSource{
|
|
LocalObjectReference: corev1.LocalObjectReference{
|
|
Name: "rollout-secret",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewRolloutWorkload(rollout, testRolloutStrategyAnnotation)
|
|
|
|
if !w.UsesSecret("rollout-secret") {
|
|
t.Error("Rollout UsesSecret should return true for Secret envFrom")
|
|
}
|
|
if w.UsesSecret("other-secret") {
|
|
t.Error("Rollout UsesSecret should return false for non-existent Secret")
|
|
}
|
|
}
|
|
|
|
func TestRolloutWorkload_DeepCopy(t *testing.T) {
|
|
rollout := &argorolloutv1alpha1.Rollout{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test"},
|
|
Spec: argorolloutv1alpha1.RolloutSpec{
|
|
Template: corev1.PodTemplateSpec{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Annotations: map[string]string{
|
|
"original": "value",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewRolloutWorkload(rollout, testRolloutStrategyAnnotation)
|
|
copy := w.DeepCopy()
|
|
|
|
// Verify copy is independent
|
|
w.SetPodTemplateAnnotation("modified", "true")
|
|
|
|
copyAnnotations := copy.(*RolloutWorkload).GetPodTemplateAnnotations()
|
|
if copyAnnotations["modified"] == "true" {
|
|
t.Error("DeepCopy should create independent copy")
|
|
}
|
|
}
|
|
|
|
func TestRolloutStrategy_Validate(t *testing.T) {
|
|
tests := []struct {
|
|
strategy RolloutStrategy
|
|
wantErr bool
|
|
}{
|
|
{RolloutStrategyRollout, false},
|
|
{RolloutStrategyRestart, false},
|
|
{RolloutStrategy("invalid"), true},
|
|
{RolloutStrategy(""), true},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
err := tt.strategy.Validate()
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("Validate(%s) error = %v, wantErr %v", tt.strategy, err, tt.wantErr)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestToRolloutStrategy(t *testing.T) {
|
|
tests := []struct {
|
|
input string
|
|
expected RolloutStrategy
|
|
}{
|
|
{"rollout", RolloutStrategyRollout},
|
|
{"restart", RolloutStrategyRestart},
|
|
{"invalid", RolloutStrategyRollout}, // defaults to rollout
|
|
{"", RolloutStrategyRollout}, // defaults to rollout
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
result := ToRolloutStrategy(tt.input)
|
|
if result != tt.expected {
|
|
t.Errorf("ToRolloutStrategy(%s) = %v, want %v", tt.input, result, tt.expected)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Job tests
|
|
func TestJobWorkload_BasicGetters(t *testing.T) {
|
|
job := testutil.NewJobWithAnnotations("test-job", "test-ns", map[string]string{"key": "value"})
|
|
|
|
w := NewJobWorkload(job)
|
|
|
|
if w.Kind() != KindJob {
|
|
t.Errorf("Kind() = %v, want %v", w.Kind(), KindJob)
|
|
}
|
|
if w.GetName() != "test-job" {
|
|
t.Errorf("GetName() = %v, want test-job", w.GetName())
|
|
}
|
|
if w.GetNamespace() != "test-ns" {
|
|
t.Errorf("GetNamespace() = %v, want test-ns", w.GetNamespace())
|
|
}
|
|
if w.GetAnnotations()["key"] != "value" {
|
|
t.Errorf("GetAnnotations()[key] = %v, want value", w.GetAnnotations()["key"])
|
|
}
|
|
if w.GetObject() != job {
|
|
t.Error("GetObject() should return the underlying job")
|
|
}
|
|
}
|
|
|
|
func TestJobWorkload_PodTemplateAnnotations(t *testing.T) {
|
|
job := testutil.NewJob("test", "default")
|
|
job.Spec.Template.Annotations["existing"] = "annotation"
|
|
|
|
w := NewJobWorkload(job)
|
|
|
|
annotations := w.GetPodTemplateAnnotations()
|
|
if annotations["existing"] != "annotation" {
|
|
t.Errorf("GetPodTemplateAnnotations()[existing] = %v, want annotation", annotations["existing"])
|
|
}
|
|
|
|
w.SetPodTemplateAnnotation("new-key", "new-value")
|
|
if w.GetPodTemplateAnnotations()["new-key"] != "new-value" {
|
|
t.Error("SetPodTemplateAnnotation should add new annotation")
|
|
}
|
|
}
|
|
|
|
func TestJobWorkload_UsesConfigMap(t *testing.T) {
|
|
job := testutil.NewJob("test", "default")
|
|
job.Spec.Template.Spec.Volumes = []corev1.Volume{
|
|
{
|
|
Name: "config-vol",
|
|
VolumeSource: corev1.VolumeSource{
|
|
ConfigMap: &corev1.ConfigMapVolumeSource{
|
|
LocalObjectReference: corev1.LocalObjectReference{Name: "job-config"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewJobWorkload(job)
|
|
|
|
if !w.UsesConfigMap("job-config") {
|
|
t.Error("Job UsesConfigMap should return true for ConfigMap volume")
|
|
}
|
|
if w.UsesConfigMap("other-config") {
|
|
t.Error("Job UsesConfigMap should return false for non-existent ConfigMap")
|
|
}
|
|
}
|
|
|
|
func TestJobWorkload_UsesSecret(t *testing.T) {
|
|
job := testutil.NewJob("test", "default")
|
|
job.Spec.Template.Spec.Containers[0].EnvFrom = []corev1.EnvFromSource{
|
|
{
|
|
SecretRef: &corev1.SecretEnvSource{
|
|
LocalObjectReference: corev1.LocalObjectReference{Name: "job-secret"},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewJobWorkload(job)
|
|
|
|
if !w.UsesSecret("job-secret") {
|
|
t.Error("Job UsesSecret should return true for Secret envFrom")
|
|
}
|
|
}
|
|
|
|
func TestJobWorkload_DeepCopy(t *testing.T) {
|
|
job := testutil.NewJob("test", "default")
|
|
job.Spec.Template.Annotations["original"] = "value"
|
|
|
|
w := NewJobWorkload(job)
|
|
copy := w.DeepCopy()
|
|
|
|
w.SetPodTemplateAnnotation("modified", "true")
|
|
|
|
copyAnnotations := copy.GetPodTemplateAnnotations()
|
|
if copyAnnotations["modified"] == "true" {
|
|
t.Error("DeepCopy should create independent copy")
|
|
}
|
|
}
|
|
|
|
// CronJob tests
|
|
func TestCronJobWorkload_BasicGetters(t *testing.T) {
|
|
cj := testutil.NewCronJobWithAnnotations("test-cronjob", "test-ns", map[string]string{"key": "value"})
|
|
|
|
w := NewCronJobWorkload(cj)
|
|
|
|
if w.Kind() != KindCronJob {
|
|
t.Errorf("Kind() = %v, want %v", w.Kind(), KindCronJob)
|
|
}
|
|
if w.GetName() != "test-cronjob" {
|
|
t.Errorf("GetName() = %v, want test-cronjob", w.GetName())
|
|
}
|
|
if w.GetNamespace() != "test-ns" {
|
|
t.Errorf("GetNamespace() = %v, want test-ns", w.GetNamespace())
|
|
}
|
|
if w.GetAnnotations()["key"] != "value" {
|
|
t.Errorf("GetAnnotations()[key] = %v, want value", w.GetAnnotations()["key"])
|
|
}
|
|
if w.GetObject() != cj {
|
|
t.Error("GetObject() should return the underlying cronjob")
|
|
}
|
|
}
|
|
|
|
func TestCronJobWorkload_PodTemplateAnnotations(t *testing.T) {
|
|
cj := testutil.NewCronJob("test", "default")
|
|
cj.Spec.JobTemplate.Spec.Template.Annotations["existing"] = "annotation"
|
|
|
|
w := NewCronJobWorkload(cj)
|
|
|
|
annotations := w.GetPodTemplateAnnotations()
|
|
if annotations["existing"] != "annotation" {
|
|
t.Errorf("GetPodTemplateAnnotations()[existing] = %v, want annotation", annotations["existing"])
|
|
}
|
|
|
|
w.SetPodTemplateAnnotation("new-key", "new-value")
|
|
if w.GetPodTemplateAnnotations()["new-key"] != "new-value" {
|
|
t.Error("SetPodTemplateAnnotation should add new annotation")
|
|
}
|
|
}
|
|
|
|
func TestCronJobWorkload_UsesConfigMap(t *testing.T) {
|
|
cj := testutil.NewCronJob("test", "default")
|
|
cj.Spec.JobTemplate.Spec.Template.Spec.Volumes = []corev1.Volume{
|
|
{
|
|
Name: "config-vol",
|
|
VolumeSource: corev1.VolumeSource{
|
|
ConfigMap: &corev1.ConfigMapVolumeSource{
|
|
LocalObjectReference: corev1.LocalObjectReference{Name: "cronjob-config"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewCronJobWorkload(cj)
|
|
|
|
if !w.UsesConfigMap("cronjob-config") {
|
|
t.Error("CronJob UsesConfigMap should return true for ConfigMap volume")
|
|
}
|
|
if w.UsesConfigMap("other-config") {
|
|
t.Error("CronJob UsesConfigMap should return false for non-existent ConfigMap")
|
|
}
|
|
}
|
|
|
|
func TestCronJobWorkload_UsesSecret(t *testing.T) {
|
|
cj := testutil.NewCronJob("test", "default")
|
|
addEnvVarSecretRef(cj.Spec.JobTemplate.Spec.Template.Spec.Containers, "SECRET_VALUE", "cronjob-secret", "key")
|
|
|
|
w := NewCronJobWorkload(cj)
|
|
|
|
if !w.UsesSecret("cronjob-secret") {
|
|
t.Error("CronJob UsesSecret should return true for Secret envVar")
|
|
}
|
|
}
|
|
|
|
func TestCronJobWorkload_DeepCopy(t *testing.T) {
|
|
cj := testutil.NewCronJob("test", "default")
|
|
cj.Spec.JobTemplate.Spec.Template.Annotations["original"] = "value"
|
|
|
|
w := NewCronJobWorkload(cj)
|
|
copy := w.DeepCopy()
|
|
|
|
w.SetPodTemplateAnnotation("modified", "true")
|
|
|
|
copyAnnotations := copy.GetPodTemplateAnnotations()
|
|
if copyAnnotations["modified"] == "true" {
|
|
t.Error("DeepCopy should create independent copy")
|
|
}
|
|
}
|
|
|
|
// Test that Job and CronJob implement the interface
|
|
func TestJobCronJobWorkloadInterface(t *testing.T) {
|
|
var _ Workload = (*JobWorkload)(nil)
|
|
var _ Workload = (*CronJobWorkload)(nil)
|
|
}
|
|
|
|
// DeploymentConfig tests
|
|
func TestDeploymentConfigWorkload_BasicGetters(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test-dc", "test-ns", map[string]string{"key": "value"})
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
if w.Kind() != KindDeploymentConfig {
|
|
t.Errorf("Kind() = %v, want %v", w.Kind(), KindDeploymentConfig)
|
|
}
|
|
if w.GetName() != "test-dc" {
|
|
t.Errorf("GetName() = %v, want test-dc", w.GetName())
|
|
}
|
|
if w.GetNamespace() != "test-ns" {
|
|
t.Errorf("GetNamespace() = %v, want test-ns", w.GetNamespace())
|
|
}
|
|
if w.GetAnnotations()["key"] != "value" {
|
|
t.Errorf("GetAnnotations()[key] = %v, want value", w.GetAnnotations()["key"])
|
|
}
|
|
if w.GetObject() != dc {
|
|
t.Error("GetObject() should return the underlying deploymentconfig")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_PodTemplateAnnotations(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.Spec.Template.Annotations = map[string]string{"existing": "annotation"}
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
annotations := w.GetPodTemplateAnnotations()
|
|
if annotations["existing"] != "annotation" {
|
|
t.Errorf("GetPodTemplateAnnotations()[existing] = %v, want annotation", annotations["existing"])
|
|
}
|
|
|
|
w.SetPodTemplateAnnotation("new-key", "new-value")
|
|
if w.GetPodTemplateAnnotations()["new-key"] != "new-value" {
|
|
t.Error("SetPodTemplateAnnotation should add new annotation")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_PodTemplateAnnotations_NilTemplate(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.Spec.Template = nil
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
// Should handle nil template gracefully
|
|
annotations := w.GetPodTemplateAnnotations()
|
|
if annotations != nil {
|
|
t.Error("GetPodTemplateAnnotations should return nil for nil template")
|
|
}
|
|
|
|
// SetPodTemplateAnnotation should initialize template
|
|
w.SetPodTemplateAnnotation("key", "value")
|
|
if w.GetPodTemplateAnnotations()["key"] != "value" {
|
|
t.Error("SetPodTemplateAnnotation should work with nil template")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_PodTemplateAnnotations_NilInit(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.Spec.Template.Annotations = nil
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
// Should initialize nil map
|
|
annotations := w.GetPodTemplateAnnotations()
|
|
if annotations == nil {
|
|
t.Error("GetPodTemplateAnnotations should initialize nil map")
|
|
}
|
|
|
|
w.SetPodTemplateAnnotation("key", "value")
|
|
if w.GetPodTemplateAnnotations()["key"] != "value" {
|
|
t.Error("SetPodTemplateAnnotation should work with nil initial map")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_Containers(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.Spec.Template.Spec.Containers = []corev1.Container{
|
|
{Name: "main", Image: "nginx"},
|
|
}
|
|
dc.Spec.Template.Spec.InitContainers = []corev1.Container{
|
|
{Name: "init", Image: "busybox"},
|
|
}
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
containers := w.GetContainers()
|
|
if len(containers) != 1 || containers[0].Name != "main" {
|
|
t.Errorf("GetContainers() = %v, want [main]", containers)
|
|
}
|
|
|
|
initContainers := w.GetInitContainers()
|
|
if len(initContainers) != 1 || initContainers[0].Name != "init" {
|
|
t.Errorf("GetInitContainers() = %v, want [init]", initContainers)
|
|
}
|
|
|
|
newContainers := []corev1.Container{{Name: "new-main", Image: "alpine"}}
|
|
w.SetContainers(newContainers)
|
|
if w.GetContainers()[0].Name != "new-main" {
|
|
t.Error("SetContainers should update containers")
|
|
}
|
|
|
|
newInitContainers := []corev1.Container{{Name: "new-init", Image: "alpine"}}
|
|
w.SetInitContainers(newInitContainers)
|
|
if w.GetInitContainers()[0].Name != "new-init" {
|
|
t.Error("SetInitContainers should update init containers")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_Containers_NilTemplate(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.Spec.Template = nil
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
if w.GetContainers() != nil {
|
|
t.Error("GetContainers should return nil for nil template")
|
|
}
|
|
if w.GetInitContainers() != nil {
|
|
t.Error("GetInitContainers should return nil for nil template")
|
|
}
|
|
|
|
// SetContainers should initialize template
|
|
w.SetContainers([]corev1.Container{{Name: "main"}})
|
|
if len(w.GetContainers()) != 1 {
|
|
t.Error("SetContainers should work with nil template")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_Volumes(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.Spec.Template.Spec.Volumes = []corev1.Volume{
|
|
{Name: "config-vol"},
|
|
{Name: "secret-vol"},
|
|
}
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
volumes := w.GetVolumes()
|
|
if len(volumes) != 2 {
|
|
t.Errorf("GetVolumes() length = %d, want 2", len(volumes))
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_Volumes_NilTemplate(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.Spec.Template = nil
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
if w.GetVolumes() != nil {
|
|
t.Error("GetVolumes should return nil for nil template")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_UsesConfigMap_Volume(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.Spec.Template.Spec.Volumes = []corev1.Volume{
|
|
{
|
|
Name: "config-vol",
|
|
VolumeSource: corev1.VolumeSource{
|
|
ConfigMap: &corev1.ConfigMapVolumeSource{
|
|
LocalObjectReference: corev1.LocalObjectReference{
|
|
Name: "dc-config",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
if !w.UsesConfigMap("dc-config") {
|
|
t.Error("DeploymentConfig UsesConfigMap should return true for ConfigMap volume")
|
|
}
|
|
if w.UsesConfigMap("other-config") {
|
|
t.Error("UsesConfigMap should return false for non-existent ConfigMap")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_UsesConfigMap_EnvFrom(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.Spec.Template.Spec.Containers = []corev1.Container{
|
|
{
|
|
Name: "main",
|
|
EnvFrom: []corev1.EnvFromSource{
|
|
{
|
|
ConfigMapRef: &corev1.ConfigMapEnvSource{
|
|
LocalObjectReference: corev1.LocalObjectReference{
|
|
Name: "dc-env-config",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
if !w.UsesConfigMap("dc-env-config") {
|
|
t.Error("DeploymentConfig UsesConfigMap should return true for envFrom ConfigMap")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_UsesConfigMap_NilTemplate(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.Spec.Template = nil
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
if w.UsesConfigMap("any-config") {
|
|
t.Error("UsesConfigMap should return false for nil template")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_UsesSecret_Volume(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.Spec.Template.Spec.Volumes = []corev1.Volume{
|
|
{
|
|
Name: "secret-vol",
|
|
VolumeSource: corev1.VolumeSource{
|
|
Secret: &corev1.SecretVolumeSource{
|
|
SecretName: "dc-secret",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
if !w.UsesSecret("dc-secret") {
|
|
t.Error("DeploymentConfig UsesSecret should return true for Secret volume")
|
|
}
|
|
if w.UsesSecret("other-secret") {
|
|
t.Error("UsesSecret should return false for non-existent Secret")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_UsesSecret_EnvFrom(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.Spec.Template.Spec.Containers = []corev1.Container{
|
|
{
|
|
Name: "main",
|
|
EnvFrom: []corev1.EnvFromSource{
|
|
{
|
|
SecretRef: &corev1.SecretEnvSource{
|
|
LocalObjectReference: corev1.LocalObjectReference{
|
|
Name: "dc-env-secret",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
if !w.UsesSecret("dc-env-secret") {
|
|
t.Error("DeploymentConfig UsesSecret should return true for envFrom Secret")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_UsesSecret_NilTemplate(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.Spec.Template = nil
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
if w.UsesSecret("any-secret") {
|
|
t.Error("UsesSecret should return false for nil template")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_GetEnvFromSources(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.Spec.Template.Spec.Containers = []corev1.Container{
|
|
{
|
|
Name: "main",
|
|
EnvFrom: []corev1.EnvFromSource{
|
|
{ConfigMapRef: &corev1.ConfigMapEnvSource{LocalObjectReference: corev1.LocalObjectReference{Name: "cm1"}}},
|
|
},
|
|
},
|
|
}
|
|
dc.Spec.Template.Spec.InitContainers = []corev1.Container{
|
|
{
|
|
Name: "init",
|
|
EnvFrom: []corev1.EnvFromSource{
|
|
{SecretRef: &corev1.SecretEnvSource{LocalObjectReference: corev1.LocalObjectReference{Name: "secret1"}}},
|
|
},
|
|
},
|
|
}
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
sources := w.GetEnvFromSources()
|
|
if len(sources) != 2 {
|
|
t.Errorf("GetEnvFromSources() returned %d sources, want 2", len(sources))
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_GetEnvFromSources_NilTemplate(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.Spec.Template = nil
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
if w.GetEnvFromSources() != nil {
|
|
t.Error("GetEnvFromSources should return nil for nil template")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_DeepCopy(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.Spec.Template.Annotations = map[string]string{"original": "value"}
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
copy := w.DeepCopy()
|
|
|
|
w.SetPodTemplateAnnotation("modified", "true")
|
|
|
|
copyAnnotations := copy.GetPodTemplateAnnotations()
|
|
if copyAnnotations["modified"] == "true" {
|
|
t.Error("DeepCopy should create independent copy")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_GetOwnerReferences(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
dc.OwnerReferences = []metav1.OwnerReference{
|
|
{
|
|
APIVersion: "apps.openshift.io/v1",
|
|
Kind: "DeploymentConfig",
|
|
Name: "test-owner",
|
|
},
|
|
}
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
refs := w.GetOwnerReferences()
|
|
if len(refs) != 1 || refs[0].Name != "test-owner" {
|
|
t.Errorf("GetOwnerReferences() = %v, want owner ref to test-owner", refs)
|
|
}
|
|
}
|
|
|
|
func TestDeploymentConfigWorkload_GetDeploymentConfig(t *testing.T) {
|
|
dc := testutil.NewDeploymentConfig("test", "default", nil)
|
|
|
|
w := NewDeploymentConfigWorkload(dc)
|
|
|
|
if w.GetDeploymentConfig() != dc {
|
|
t.Error("GetDeploymentConfig should return the underlying DeploymentConfig")
|
|
}
|
|
}
|
|
|
|
// Test that DeploymentConfig implements the interface
|
|
func TestDeploymentConfigWorkloadInterface(t *testing.T) {
|
|
var _ Workload = (*DeploymentConfigWorkload)(nil)
|
|
}
|
|
|
|
// Tests for UpdateStrategy
|
|
func TestWorkload_UpdateStrategy(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
workload Workload
|
|
expected UpdateStrategy
|
|
}{
|
|
{
|
|
name: "Deployment uses Patch strategy",
|
|
workload: NewDeploymentWorkload(testutil.NewDeployment("test", "default", nil)),
|
|
expected: UpdateStrategyPatch,
|
|
},
|
|
{
|
|
name: "DaemonSet uses Patch strategy",
|
|
workload: NewDaemonSetWorkload(testutil.NewDaemonSet("test", "default", nil)),
|
|
expected: UpdateStrategyPatch,
|
|
},
|
|
{
|
|
name: "StatefulSet uses Patch strategy",
|
|
workload: NewStatefulSetWorkload(testutil.NewStatefulSet("test", "default", nil)),
|
|
expected: UpdateStrategyPatch,
|
|
},
|
|
{
|
|
name: "Job uses Recreate strategy",
|
|
workload: NewJobWorkload(testutil.NewJob("test", "default")),
|
|
expected: UpdateStrategyRecreate,
|
|
},
|
|
{
|
|
name: "CronJob uses CreateNew strategy",
|
|
workload: NewCronJobWorkload(testutil.NewCronJob("test", "default")),
|
|
expected: UpdateStrategyCreateNew,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := tt.workload.UpdateStrategy(); got != tt.expected {
|
|
t.Errorf("UpdateStrategy() = %v, want %v", got, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Tests for ResetOriginal
|
|
func TestDeploymentWorkload_ResetOriginal(t *testing.T) {
|
|
deploy := testutil.NewDeployment("test", "default", nil)
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
// Modify the workload
|
|
w.SetPodTemplateAnnotation("modified", "true")
|
|
|
|
// Original should still not have the annotation
|
|
originalAnnotations := w.Original().Spec.Template.Annotations
|
|
if originalAnnotations != nil && originalAnnotations["modified"] == "true" {
|
|
t.Error("Original should not be modified yet")
|
|
}
|
|
|
|
// Reset original
|
|
w.ResetOriginal()
|
|
|
|
// Now original should have the annotation
|
|
if w.Original().Spec.Template.Annotations["modified"] != "true" {
|
|
t.Error("ResetOriginal should update original to match current state")
|
|
}
|
|
}
|
|
|
|
func TestJobWorkload_ResetOriginal(t *testing.T) {
|
|
job := testutil.NewJob("test", "default")
|
|
w := NewJobWorkload(job)
|
|
|
|
// ResetOriginal should be a no-op for Jobs (they don't use strategic merge patch)
|
|
w.SetPodTemplateAnnotation("modified", "true")
|
|
w.ResetOriginal() // Should not panic or error
|
|
}
|
|
|
|
func TestCronJobWorkload_ResetOriginal(t *testing.T) {
|
|
cj := testutil.NewCronJob("test", "default")
|
|
w := NewCronJobWorkload(cj)
|
|
|
|
// ResetOriginal should be a no-op for CronJobs
|
|
w.SetPodTemplateAnnotation("modified", "true")
|
|
w.ResetOriginal() // Should not panic or error
|
|
}
|
|
|
|
// Tests for BaseWorkload.Original()
|
|
func TestDeploymentWorkload_Original(t *testing.T) {
|
|
deploy := testutil.NewDeployment("test", "default", nil)
|
|
deploy.Spec.Template.Annotations = map[string]string{"initial": "value"}
|
|
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
// Modify the current object
|
|
w.SetPodTemplateAnnotation("new", "annotation")
|
|
|
|
// Original should still have only the initial annotation
|
|
original := w.Original()
|
|
if original.Spec.Template.Annotations["new"] == "annotation" {
|
|
t.Error("Original should not reflect changes to current object")
|
|
}
|
|
if original.Spec.Template.Annotations["initial"] != "value" {
|
|
t.Error("Original should retain initial state")
|
|
}
|
|
}
|
|
|
|
// Tests for PerformSpecialUpdate returning false for standard workloads
|
|
func TestDeploymentWorkload_PerformSpecialUpdate(t *testing.T) {
|
|
deploy := testutil.NewDeployment("test", "default", nil)
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
updated, err := w.PerformSpecialUpdate(t.Context(), nil)
|
|
if err != nil {
|
|
t.Errorf("PerformSpecialUpdate() error = %v", err)
|
|
}
|
|
if updated {
|
|
t.Error("PerformSpecialUpdate() should return false for Deployment")
|
|
}
|
|
}
|
|
|
|
func TestDaemonSetWorkload_PerformSpecialUpdate(t *testing.T) {
|
|
ds := testutil.NewDaemonSet("test", "default", nil)
|
|
w := NewDaemonSetWorkload(ds)
|
|
|
|
updated, err := w.PerformSpecialUpdate(t.Context(), nil)
|
|
if err != nil {
|
|
t.Errorf("PerformSpecialUpdate() error = %v", err)
|
|
}
|
|
if updated {
|
|
t.Error("PerformSpecialUpdate() should return false for DaemonSet")
|
|
}
|
|
}
|
|
|
|
func TestStatefulSetWorkload_PerformSpecialUpdate(t *testing.T) {
|
|
ss := testutil.NewStatefulSet("test", "default", nil)
|
|
w := NewStatefulSetWorkload(ss)
|
|
|
|
updated, err := w.PerformSpecialUpdate(t.Context(), nil)
|
|
if err != nil {
|
|
t.Errorf("PerformSpecialUpdate() error = %v", err)
|
|
}
|
|
if updated {
|
|
t.Error("PerformSpecialUpdate() should return false for StatefulSet")
|
|
}
|
|
}
|
|
|
|
// Test Update returns nil for Job (no-op, uses PerformSpecialUpdate instead)
|
|
func TestJobWorkload_Update(t *testing.T) {
|
|
job := testutil.NewJob("test", "default")
|
|
w := NewJobWorkload(job)
|
|
|
|
err := w.Update(t.Context(), nil)
|
|
if err != nil {
|
|
t.Errorf("Update() should return nil for Job, got %v", err)
|
|
}
|
|
}
|
|
|
|
// Test Update returns nil for CronJob (no-op, uses PerformSpecialUpdate instead)
|
|
func TestCronJobWorkload_Update(t *testing.T) {
|
|
cj := testutil.NewCronJob("test", "default")
|
|
w := NewCronJobWorkload(cj)
|
|
|
|
err := w.Update(t.Context(), nil)
|
|
if err != nil {
|
|
t.Errorf("Update() should return nil for CronJob, got %v", err)
|
|
}
|
|
}
|
|
|
|
// Test GetJob and GetCronJob accessors
|
|
func TestJobWorkload_GetJob(t *testing.T) {
|
|
job := testutil.NewJob("test", "default")
|
|
w := NewJobWorkload(job)
|
|
|
|
if w.GetJob() != job {
|
|
t.Error("GetJob should return the underlying Job")
|
|
}
|
|
}
|
|
|
|
func TestCronJobWorkload_GetCronJob(t *testing.T) {
|
|
cj := testutil.NewCronJob("test", "default")
|
|
w := NewCronJobWorkload(cj)
|
|
|
|
if w.GetCronJob() != cj {
|
|
t.Error("GetCronJob should return the underlying CronJob")
|
|
}
|
|
}
|
|
|
|
func TestDeploymentWorkload_GetDeployment(t *testing.T) {
|
|
deploy := testutil.NewDeployment("test", "default", nil)
|
|
w := NewDeploymentWorkload(deploy)
|
|
|
|
if w.GetDeployment() != deploy {
|
|
t.Error("GetDeployment should return the underlying Deployment")
|
|
}
|
|
}
|
|
|
|
func TestDaemonSetWorkload_GetDaemonSet(t *testing.T) {
|
|
ds := testutil.NewDaemonSet("test", "default", nil)
|
|
w := NewDaemonSetWorkload(ds)
|
|
|
|
if w.GetDaemonSet() != ds {
|
|
t.Error("GetDaemonSet should return the underlying DaemonSet")
|
|
}
|
|
}
|
|
|
|
func TestStatefulSetWorkload_GetStatefulSet(t *testing.T) {
|
|
ss := testutil.NewStatefulSet("test", "default", nil)
|
|
w := NewStatefulSetWorkload(ss)
|
|
|
|
if w.GetStatefulSet() != ss {
|
|
t.Error("GetStatefulSet should return the underlying StatefulSet")
|
|
}
|
|
}
|
|
|
|
func TestRolloutWorkload_GetRollout(t *testing.T) {
|
|
rollout := &argorolloutv1alpha1.Rollout{
|
|
ObjectMeta: metav1.ObjectMeta{Name: "test", Namespace: "default"},
|
|
}
|
|
w := NewRolloutWorkload(rollout, testRolloutStrategyAnnotation)
|
|
|
|
if w.GetRollout() != rollout {
|
|
t.Error("GetRollout should return the underlying Rollout")
|
|
}
|
|
}
|