mirror of
https://github.com/stakater/Reloader.git
synced 2026-08-20 12:36:26 +00:00
588 lines
16 KiB
Go
588 lines
16 KiB
Go
package controller_test
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"github.com/go-logr/logr/testr"
|
|
appsv1 "k8s.io/api/apps/v1"
|
|
batchv1 "k8s.io/api/batch/v1"
|
|
corev1 "k8s.io/api/core/v1"
|
|
"k8s.io/apimachinery/pkg/runtime"
|
|
"k8s.io/apimachinery/pkg/types"
|
|
"sigs.k8s.io/controller-runtime/pkg/client"
|
|
"sigs.k8s.io/controller-runtime/pkg/client/fake"
|
|
|
|
"github.com/stakater/Reloader/internal/pkg/config"
|
|
"github.com/stakater/Reloader/internal/pkg/controller"
|
|
"github.com/stakater/Reloader/internal/pkg/reload"
|
|
"github.com/stakater/Reloader/internal/pkg/testutil"
|
|
"github.com/stakater/Reloader/internal/pkg/workload"
|
|
)
|
|
|
|
func TestUpdateWorkloadWithRetry_WorkloadTypes(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
object runtime.Object
|
|
workload func(runtime.Object) workload.Workload
|
|
resourceType reload.ResourceType
|
|
verify func(t *testing.T, c client.Client)
|
|
}{
|
|
{
|
|
name: "Deployment",
|
|
object: testutil.NewDeployment("test-deployment", "default", nil),
|
|
workload: func(o runtime.Object) workload.Workload {
|
|
return workload.NewDeploymentWorkload(o.(*appsv1.Deployment))
|
|
},
|
|
resourceType: reload.ResourceTypeConfigMap,
|
|
verify: func(t *testing.T, c client.Client) {
|
|
var result appsv1.Deployment
|
|
if err := c.Get(context.Background(), types.NamespacedName{Name: "test-deployment", Namespace: "default"}, &result); err != nil {
|
|
t.Fatalf("Failed to get deployment: %v", err)
|
|
}
|
|
if result.Spec.Template.Annotations == nil {
|
|
t.Fatal("Expected pod template annotations to be set")
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "DaemonSet",
|
|
object: testutil.NewDaemonSet("test-daemonset", "default", nil),
|
|
workload: func(o runtime.Object) workload.Workload {
|
|
return workload.NewDaemonSetWorkload(o.(*appsv1.DaemonSet))
|
|
},
|
|
resourceType: reload.ResourceTypeSecret,
|
|
verify: func(t *testing.T, c client.Client) {
|
|
var result appsv1.DaemonSet
|
|
if err := c.Get(context.Background(), types.NamespacedName{Name: "test-daemonset", Namespace: "default"}, &result); err != nil {
|
|
t.Fatalf("Failed to get daemonset: %v", err)
|
|
}
|
|
if result.Spec.Template.Annotations == nil {
|
|
t.Fatal("Expected pod template annotations to be set")
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "StatefulSet",
|
|
object: testutil.NewStatefulSet("test-statefulset", "default", nil),
|
|
workload: func(o runtime.Object) workload.Workload {
|
|
return workload.NewStatefulSetWorkload(o.(*appsv1.StatefulSet))
|
|
},
|
|
resourceType: reload.ResourceTypeConfigMap,
|
|
verify: func(t *testing.T, c client.Client) {
|
|
var result appsv1.StatefulSet
|
|
if err := c.Get(context.Background(), types.NamespacedName{Name: "test-statefulset", Namespace: "default"}, &result); err != nil {
|
|
t.Fatalf("Failed to get statefulset: %v", err)
|
|
}
|
|
if result.Spec.Template.Annotations == nil {
|
|
t.Fatal("Expected pod template annotations to be set")
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "Job",
|
|
object: testutil.NewJob("test-job", "default"),
|
|
workload: func(o runtime.Object) workload.Workload {
|
|
return workload.NewJobWorkload(o.(*batchv1.Job))
|
|
},
|
|
resourceType: reload.ResourceTypeConfigMap,
|
|
verify: func(t *testing.T, c client.Client) {
|
|
var jobs batchv1.JobList
|
|
if err := c.List(context.Background(), &jobs, client.InNamespace("default")); err != nil {
|
|
t.Fatalf("Failed to list jobs: %v", err)
|
|
}
|
|
if len(jobs.Items) != 1 {
|
|
t.Errorf("Expected 1 job (recreated), got %d", len(jobs.Items))
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "CronJob",
|
|
object: testutil.NewCronJob("test-cronjob", "default"),
|
|
workload: func(o runtime.Object) workload.Workload {
|
|
return workload.NewCronJobWorkload(o.(*batchv1.CronJob))
|
|
},
|
|
resourceType: reload.ResourceTypeSecret,
|
|
verify: func(t *testing.T, c client.Client) {
|
|
var jobs batchv1.JobList
|
|
if err := c.List(context.Background(), &jobs, client.InNamespace("default")); err != nil {
|
|
t.Fatalf("Failed to list jobs: %v", err)
|
|
}
|
|
if len(jobs.Items) != 1 {
|
|
t.Errorf("Expected 1 job from cronjob, got %d", len(jobs.Items))
|
|
}
|
|
if len(jobs.Items) > 0 && jobs.Items[0].Annotations["cronjob.kubernetes.io/instantiate"] != "manual" {
|
|
t.Error("Expected job to have manual instantiate annotation")
|
|
}
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(
|
|
tt.name, func(t *testing.T) {
|
|
cfg := config.NewDefault()
|
|
reloadService := reload.NewService(cfg, testr.New(t))
|
|
|
|
fakeClient := fake.NewClientBuilder().
|
|
WithScheme(testutil.NewScheme()).
|
|
WithRuntimeObjects(tt.object).
|
|
Build()
|
|
|
|
wl := tt.workload(tt.object)
|
|
|
|
updated, err := controller.UpdateWorkloadWithRetry(
|
|
context.Background(),
|
|
fakeClient,
|
|
reloadService,
|
|
nil, // no pause handler
|
|
wl,
|
|
"test-resource",
|
|
tt.resourceType,
|
|
"default",
|
|
"abc123",
|
|
false,
|
|
)
|
|
|
|
if err != nil {
|
|
t.Fatalf("UpdateWorkloadWithRetry failed: %v", err)
|
|
}
|
|
if !updated {
|
|
t.Error("Expected workload to be updated")
|
|
}
|
|
|
|
tt.verify(t, fakeClient)
|
|
},
|
|
)
|
|
}
|
|
}
|
|
|
|
func TestUpdateWorkloadWithRetry_Strategies(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
strategy config.ReloadStrategy
|
|
verify func(t *testing.T, cfg *config.Config, result *appsv1.Deployment)
|
|
}{
|
|
{
|
|
name: "EnvVarStrategy",
|
|
strategy: config.ReloadStrategyEnvVars,
|
|
verify: func(t *testing.T, cfg *config.Config, result *appsv1.Deployment) {
|
|
found := false
|
|
for _, env := range result.Spec.Template.Spec.Containers[0].Env {
|
|
if env.Name == "STAKATER_TEST_CM_CONFIGMAP" && env.Value == "abc123" {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Error("Expected STAKATER_TEST_CM_CONFIGMAP env var to be set")
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "AnnotationStrategy",
|
|
strategy: config.ReloadStrategyAnnotations,
|
|
verify: func(t *testing.T, cfg *config.Config, result *appsv1.Deployment) {
|
|
if result.Spec.Template.Annotations == nil {
|
|
t.Fatal("Expected pod template annotations to be set")
|
|
}
|
|
if _, ok := result.Spec.Template.Annotations[cfg.Annotations.LastReloadedFrom]; !ok {
|
|
t.Errorf("Expected %s annotation to be set", cfg.Annotations.LastReloadedFrom)
|
|
}
|
|
for _, env := range result.Spec.Template.Spec.Containers[0].Env {
|
|
if env.Name == "STAKATER_TEST_CM_CONFIGMAP" {
|
|
t.Error("Annotation strategy should not add env vars")
|
|
}
|
|
}
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(
|
|
tt.name, func(t *testing.T) {
|
|
cfg := config.NewDefault()
|
|
cfg.ReloadStrategy = tt.strategy
|
|
reloadService := reload.NewService(cfg, testr.New(t))
|
|
|
|
deployment := testutil.NewDeployment("test-deployment", "default", nil)
|
|
fakeClient := fake.NewClientBuilder().
|
|
WithScheme(testutil.NewScheme()).
|
|
WithObjects(deployment).
|
|
Build()
|
|
|
|
wl := workload.NewDeploymentWorkload(deployment)
|
|
|
|
updated, err := controller.UpdateWorkloadWithRetry(
|
|
context.Background(),
|
|
fakeClient,
|
|
reloadService,
|
|
nil, // no pause handler for this test
|
|
wl,
|
|
"test-cm",
|
|
reload.ResourceTypeConfigMap,
|
|
"default",
|
|
"abc123",
|
|
false,
|
|
)
|
|
|
|
if err != nil {
|
|
t.Fatalf("UpdateWorkloadWithRetry failed: %v", err)
|
|
}
|
|
if !updated {
|
|
t.Error("Expected workload to be updated")
|
|
}
|
|
|
|
var result appsv1.Deployment
|
|
if err := fakeClient.Get(
|
|
context.Background(), types.NamespacedName{Name: "test-deployment", Namespace: "default"}, &result,
|
|
); err != nil {
|
|
t.Fatalf("Failed to get deployment: %v", err)
|
|
}
|
|
|
|
tt.verify(t, cfg, &result)
|
|
},
|
|
)
|
|
}
|
|
}
|
|
|
|
func TestUpdateWorkloadWithRetry_NoUpdate(t *testing.T) {
|
|
cfg := config.NewDefault()
|
|
reloadService := reload.NewService(cfg, testr.New(t))
|
|
|
|
deployment := testutil.NewDeployment("test-deployment", "default", nil)
|
|
deployment.Spec.Template.Spec.Containers[0].Env = []corev1.EnvVar{
|
|
{
|
|
Name: "STAKATER_TEST_CM_CONFIGMAP",
|
|
Value: "abc123",
|
|
},
|
|
}
|
|
|
|
fakeClient := fake.NewClientBuilder().
|
|
WithScheme(testutil.NewScheme()).
|
|
WithObjects(deployment).
|
|
Build()
|
|
|
|
wl := workload.NewDeploymentWorkload(deployment)
|
|
|
|
updated, err := controller.UpdateWorkloadWithRetry(
|
|
context.Background(),
|
|
fakeClient,
|
|
reloadService,
|
|
nil, // no pause handler
|
|
wl,
|
|
"test-cm",
|
|
reload.ResourceTypeConfigMap,
|
|
"default",
|
|
"abc123", // Same hash as already set
|
|
false,
|
|
)
|
|
|
|
if err != nil {
|
|
t.Fatalf("UpdateWorkloadWithRetry failed: %v", err)
|
|
}
|
|
if updated {
|
|
t.Error("Expected workload NOT to be updated (same hash)")
|
|
}
|
|
}
|
|
|
|
func TestResourceTypeKind(t *testing.T) {
|
|
tests := []struct {
|
|
resourceType reload.ResourceType
|
|
expectedKind string
|
|
}{
|
|
{reload.ResourceTypeConfigMap, "ConfigMap"},
|
|
{reload.ResourceTypeSecret, "Secret"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(
|
|
string(tt.resourceType), func(t *testing.T) {
|
|
if got := tt.resourceType.Kind(); got != tt.expectedKind {
|
|
t.Errorf("ResourceType.Kind() = %v, want %v", got, tt.expectedKind)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
}
|
|
|
|
func TestUpdateWorkloadWithRetry_PauseDeployment(t *testing.T) {
|
|
cfg := config.NewDefault()
|
|
reloadService := reload.NewService(cfg, testr.New(t))
|
|
pauseHandler := reload.NewPauseHandler(cfg)
|
|
|
|
deployment := testutil.NewDeployment(
|
|
"test-deployment", "default", map[string]string{
|
|
"reloader.stakater.com/auto": "true",
|
|
"deployment.reloader.stakater.com/pause-period": "5m",
|
|
},
|
|
)
|
|
|
|
fakeClient := fake.NewClientBuilder().
|
|
WithScheme(testutil.NewScheme()).
|
|
WithObjects(deployment).
|
|
Build()
|
|
|
|
wl := workload.NewDeploymentWorkload(deployment)
|
|
|
|
updated, err := controller.UpdateWorkloadWithRetry(
|
|
context.Background(),
|
|
fakeClient,
|
|
reloadService,
|
|
pauseHandler,
|
|
wl,
|
|
"test-cm",
|
|
reload.ResourceTypeConfigMap,
|
|
"default",
|
|
"abc123",
|
|
true,
|
|
)
|
|
|
|
if err != nil {
|
|
t.Fatalf("UpdateWorkloadWithRetry failed: %v", err)
|
|
}
|
|
if !updated {
|
|
t.Error("Expected workload to be updated")
|
|
}
|
|
|
|
var result appsv1.Deployment
|
|
if err := fakeClient.Get(
|
|
context.Background(), types.NamespacedName{Name: "test-deployment", Namespace: "default"}, &result,
|
|
); err != nil {
|
|
t.Fatalf("Failed to get deployment: %v", err)
|
|
}
|
|
|
|
if result.Spec.Template.Annotations == nil {
|
|
t.Fatal("Expected pod template annotations to be set")
|
|
}
|
|
|
|
if !result.Spec.Paused {
|
|
t.Error("Expected deployment to be paused (spec.Paused=true)")
|
|
}
|
|
|
|
pausedAt := result.Annotations[cfg.Annotations.PausedAt]
|
|
if pausedAt == "" {
|
|
t.Error("Expected paused-at annotation to be set")
|
|
}
|
|
}
|
|
|
|
// TestUpdateWorkloadWithRetry_PauseWithExplicitAnnotation tests pause with explicit configmap annotation (no auto).
|
|
func TestUpdateWorkloadWithRetry_PauseWithExplicitAnnotation(t *testing.T) {
|
|
cfg := config.NewDefault()
|
|
reloadService := reload.NewService(cfg, testr.New(t))
|
|
pauseHandler := reload.NewPauseHandler(cfg)
|
|
|
|
deployment := testutil.NewDeployment(
|
|
"test-deployment", "default", map[string]string{
|
|
cfg.Annotations.ConfigmapReload: "test-cm", // explicit, not auto
|
|
cfg.Annotations.PausePeriod: "5m",
|
|
},
|
|
)
|
|
|
|
fakeClient := fake.NewClientBuilder().
|
|
WithScheme(testutil.NewScheme()).
|
|
WithObjects(deployment).
|
|
Build()
|
|
|
|
wl := workload.NewDeploymentWorkload(deployment)
|
|
|
|
updated, err := controller.UpdateWorkloadWithRetry(
|
|
context.Background(),
|
|
fakeClient,
|
|
reloadService,
|
|
pauseHandler,
|
|
wl,
|
|
"test-cm",
|
|
reload.ResourceTypeConfigMap,
|
|
"default",
|
|
"abc123",
|
|
false, // NOT auto reload
|
|
)
|
|
|
|
if err != nil {
|
|
t.Fatalf("UpdateWorkloadWithRetry failed: %v", err)
|
|
}
|
|
if !updated {
|
|
t.Error("Expected workload to be updated")
|
|
}
|
|
|
|
var result appsv1.Deployment
|
|
if err := fakeClient.Get(
|
|
context.Background(), types.NamespacedName{Name: "test-deployment", Namespace: "default"}, &result,
|
|
); err != nil {
|
|
t.Fatalf("Failed to get deployment: %v", err)
|
|
}
|
|
|
|
if result.Spec.Template.Annotations == nil {
|
|
t.Fatal("Expected pod template annotations to be set")
|
|
}
|
|
|
|
if !result.Spec.Paused {
|
|
t.Error("Expected deployment to be paused (spec.Paused=true)")
|
|
}
|
|
|
|
pausedAt := result.Annotations[cfg.Annotations.PausedAt]
|
|
if pausedAt == "" {
|
|
t.Error("Expected paused-at annotation to be set")
|
|
}
|
|
}
|
|
|
|
// TestUpdateWorkloadWithRetry_PauseWithSecretReload tests pause with Secret-triggered reload.
|
|
func TestUpdateWorkloadWithRetry_PauseWithSecretReload(t *testing.T) {
|
|
cfg := config.NewDefault()
|
|
reloadService := reload.NewService(cfg, testr.New(t))
|
|
pauseHandler := reload.NewPauseHandler(cfg)
|
|
|
|
deployment := testutil.NewDeployment(
|
|
"test-deployment", "default", map[string]string{
|
|
cfg.Annotations.SecretReload: "test-secret", // explicit secret, not auto
|
|
cfg.Annotations.PausePeriod: "5m",
|
|
},
|
|
)
|
|
|
|
fakeClient := fake.NewClientBuilder().
|
|
WithScheme(testutil.NewScheme()).
|
|
WithObjects(deployment).
|
|
Build()
|
|
|
|
wl := workload.NewDeploymentWorkload(deployment)
|
|
|
|
updated, err := controller.UpdateWorkloadWithRetry(
|
|
context.Background(),
|
|
fakeClient,
|
|
reloadService,
|
|
pauseHandler,
|
|
wl,
|
|
"test-secret",
|
|
reload.ResourceTypeSecret,
|
|
"default",
|
|
"abc123",
|
|
false,
|
|
)
|
|
|
|
if err != nil {
|
|
t.Fatalf("UpdateWorkloadWithRetry failed: %v", err)
|
|
}
|
|
if !updated {
|
|
t.Error("Expected workload to be updated")
|
|
}
|
|
|
|
var result appsv1.Deployment
|
|
if err := fakeClient.Get(
|
|
context.Background(), types.NamespacedName{Name: "test-deployment", Namespace: "default"}, &result,
|
|
); err != nil {
|
|
t.Fatalf("Failed to get deployment: %v", err)
|
|
}
|
|
|
|
if !result.Spec.Paused {
|
|
t.Error("Expected deployment to be paused (spec.Paused=true)")
|
|
}
|
|
|
|
pausedAt := result.Annotations[cfg.Annotations.PausedAt]
|
|
if pausedAt == "" {
|
|
t.Error("Expected paused-at annotation to be set")
|
|
}
|
|
}
|
|
|
|
// TestUpdateWorkloadWithRetry_PauseWithAutoSecret tests pause with auto annotation + Secret change.
|
|
func TestUpdateWorkloadWithRetry_PauseWithAutoSecret(t *testing.T) {
|
|
cfg := config.NewDefault()
|
|
reloadService := reload.NewService(cfg, testr.New(t))
|
|
pauseHandler := reload.NewPauseHandler(cfg)
|
|
|
|
deployment := testutil.NewDeployment(
|
|
"test-deployment", "default", map[string]string{
|
|
cfg.Annotations.Auto: "true",
|
|
cfg.Annotations.PausePeriod: "5m",
|
|
},
|
|
)
|
|
|
|
fakeClient := fake.NewClientBuilder().
|
|
WithScheme(testutil.NewScheme()).
|
|
WithObjects(deployment).
|
|
Build()
|
|
|
|
wl := workload.NewDeploymentWorkload(deployment)
|
|
|
|
updated, err := controller.UpdateWorkloadWithRetry(
|
|
context.Background(),
|
|
fakeClient,
|
|
reloadService,
|
|
pauseHandler,
|
|
wl,
|
|
"test-secret",
|
|
reload.ResourceTypeSecret,
|
|
"default",
|
|
"abc123",
|
|
true,
|
|
)
|
|
|
|
if err != nil {
|
|
t.Fatalf("UpdateWorkloadWithRetry failed: %v", err)
|
|
}
|
|
if !updated {
|
|
t.Error("Expected workload to be updated")
|
|
}
|
|
|
|
var result appsv1.Deployment
|
|
if err := fakeClient.Get(
|
|
context.Background(), types.NamespacedName{Name: "test-deployment", Namespace: "default"}, &result,
|
|
); err != nil {
|
|
t.Fatalf("Failed to get deployment: %v", err)
|
|
}
|
|
|
|
if !result.Spec.Paused {
|
|
t.Error("Expected deployment to be paused (spec.Paused=true)")
|
|
}
|
|
}
|
|
|
|
func TestUpdateWorkloadWithRetry_NoPauseWithoutAnnotation(t *testing.T) {
|
|
cfg := config.NewDefault()
|
|
reloadService := reload.NewService(cfg, testr.New(t))
|
|
pauseHandler := reload.NewPauseHandler(cfg)
|
|
|
|
deployment := testutil.NewDeployment(
|
|
"test-deployment", "default", map[string]string{
|
|
"reloader.stakater.com/auto": "true",
|
|
},
|
|
)
|
|
|
|
fakeClient := fake.NewClientBuilder().
|
|
WithScheme(testutil.NewScheme()).
|
|
WithObjects(deployment).
|
|
Build()
|
|
|
|
wl := workload.NewDeploymentWorkload(deployment)
|
|
|
|
updated, err := controller.UpdateWorkloadWithRetry(
|
|
context.Background(),
|
|
fakeClient,
|
|
reloadService,
|
|
pauseHandler,
|
|
wl,
|
|
"test-cm",
|
|
reload.ResourceTypeConfigMap,
|
|
"default",
|
|
"abc123",
|
|
true,
|
|
)
|
|
|
|
if err != nil {
|
|
t.Fatalf("UpdateWorkloadWithRetry failed: %v", err)
|
|
}
|
|
if !updated {
|
|
t.Error("Expected workload to be updated")
|
|
}
|
|
|
|
var result appsv1.Deployment
|
|
if err := fakeClient.Get(
|
|
context.Background(), types.NamespacedName{Name: "test-deployment", Namespace: "default"}, &result,
|
|
); err != nil {
|
|
t.Fatalf("Failed to get deployment: %v", err)
|
|
}
|
|
|
|
if result.Spec.Paused {
|
|
t.Error("Expected deployment NOT to be paused (no pause-period annotation)")
|
|
}
|
|
}
|