controller change for statefulset auto-delete (tests)

Change-Id: I16b50e6853bba65fc89c793d2b9b335581c02407

pkg/controller/statefulset/stateful_pod_control_test.go

@@ -19,23 +19,27 @@ package statefulset
 import (
 	"context"
 	"errors"
+	"fmt"
 	"strings"
 	"testing"
 	"time"
 
+	apps "k8s.io/api/apps/v1"
+	"k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
-
+	"k8s.io/apimachinery/pkg/types"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	"k8s.io/client-go/kubernetes/fake"
+	corelisters "k8s.io/client-go/listers/core/v1"
 	core "k8s.io/client-go/testing"
 	"k8s.io/client-go/tools/cache"
 	"k8s.io/client-go/tools/record"
-
-	"k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/client-go/kubernetes/fake"
-	corelisters "k8s.io/client-go/listers/core/v1"
+	featuregatetesting "k8s.io/component-base/featuregate/testing"
 	_ "k8s.io/kubernetes/pkg/apis/apps/install"
 	_ "k8s.io/kubernetes/pkg/apis/core/install"
+	"k8s.io/kubernetes/pkg/features"
 )
 
 func TestStatefulPodControlCreatesPods(t *testing.T) {
@@ -43,14 +47,15 @@ func TestStatefulPodControlCreatesPods(t *testing.T) {
 	set := newStatefulSet(3)
 	pod := newStatefulSetPod(set, 0)
 	fakeClient := &fake.Clientset{}
-	pvcIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
-	pvcLister := corelisters.NewPersistentVolumeClaimLister(pvcIndexer)
-	control := NewRealStatefulPodControl(fakeClient, nil, nil, pvcLister, recorder)
+	claimIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+	claimLister := corelisters.NewPersistentVolumeClaimLister(claimIndexer)
+	control := NewStatefulPodControl(fakeClient, nil, claimLister, recorder)
 	fakeClient.AddReactor("get", "persistentvolumeclaims", func(action core.Action) (bool, runtime.Object, error) {
 		return true, nil, apierrors.NewNotFound(action.GetResource().GroupResource(), action.GetResource().Resource)
 	})
 	fakeClient.AddReactor("create", "persistentvolumeclaims", func(action core.Action) (bool, runtime.Object, error) {
 		create := action.(core.CreateAction)
+		claimIndexer.Add(create.GetObject())
 		return true, create.GetObject(), nil
 	})
 	fakeClient.AddReactor("create", "pods", func(action core.Action) (bool, runtime.Object, error) {
@@ -83,7 +88,7 @@ func TestStatefulPodControlCreatePodExists(t *testing.T) {
 		pvcIndexer.Add(&pvc)
 	}
 	pvcLister := corelisters.NewPersistentVolumeClaimLister(pvcIndexer)
-	control := NewRealStatefulPodControl(fakeClient, nil, nil, pvcLister, recorder)
+	control := NewStatefulPodControl(fakeClient, nil, pvcLister, recorder)
 	fakeClient.AddReactor("create", "persistentvolumeclaims", func(action core.Action) (bool, runtime.Object, error) {
 		create := action.(core.CreateAction)
 		return true, create.GetObject(), nil
@@ -110,7 +115,7 @@ func TestStatefulPodControlCreatePodPvcCreateFailure(t *testing.T) {
 	fakeClient := &fake.Clientset{}
 	pvcIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
 	pvcLister := corelisters.NewPersistentVolumeClaimLister(pvcIndexer)
-	control := NewRealStatefulPodControl(fakeClient, nil, nil, pvcLister, recorder)
+	control := NewStatefulPodControl(fakeClient, nil, pvcLister, recorder)
 	fakeClient.AddReactor("create", "persistentvolumeclaims", func(action core.Action) (bool, runtime.Object, error) {
 		return true, nil, apierrors.NewInternalError(errors.New("API server down"))
 	})
@@ -131,7 +136,7 @@ func TestStatefulPodControlCreatePodPvcCreateFailure(t *testing.T) {
 		}
 	}
 }
-func TestStatefulPodControlCreatePodPvcDeleting(t *testing.T) {
+func TestStatefulPodControlCreatePodPVCDeleting(t *testing.T) {
 	recorder := record.NewFakeRecorder(10)
 	set := newStatefulSet(3)
 	pod := newStatefulSetPod(set, 0)
@@ -145,7 +150,7 @@ func TestStatefulPodControlCreatePodPvcDeleting(t *testing.T) {
 		pvcIndexer.Add(&pvc)
 	}
 	pvcLister := corelisters.NewPersistentVolumeClaimLister(pvcIndexer)
-	control := NewRealStatefulPodControl(fakeClient, nil, nil, pvcLister, recorder)
+	control := NewStatefulPodControl(fakeClient, nil, pvcLister, recorder)
 	fakeClient.AddReactor("create", "persistentvolumeclaims", func(action core.Action) (bool, runtime.Object, error) {
 		create := action.(core.CreateAction)
 		return true, create.GetObject(), nil
@@ -184,7 +189,7 @@ func TestStatefulPodControlCreatePodPvcGetFailure(t *testing.T) {
 	fakeClient := &fake.Clientset{}
 	pvcIndexer := &fakeIndexer{getError: errors.New("API server down")}
 	pvcLister := corelisters.NewPersistentVolumeClaimLister(pvcIndexer)
-	control := NewRealStatefulPodControl(fakeClient, nil, nil, pvcLister, recorder)
+	control := NewStatefulPodControl(fakeClient, nil, pvcLister, recorder)
 	fakeClient.AddReactor("create", "persistentvolumeclaims", func(action core.Action) (bool, runtime.Object, error) {
 		return true, nil, apierrors.NewInternalError(errors.New("API server down"))
 	})
@@ -213,7 +218,7 @@ func TestStatefulPodControlCreatePodFailed(t *testing.T) {
 	fakeClient := &fake.Clientset{}
 	pvcIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
 	pvcLister := corelisters.NewPersistentVolumeClaimLister(pvcIndexer)
-	control := NewRealStatefulPodControl(fakeClient, nil, nil, pvcLister, recorder)
+	control := NewStatefulPodControl(fakeClient, nil, pvcLister, recorder)
 	fakeClient.AddReactor("create", "persistentvolumeclaims", func(action core.Action) (bool, runtime.Object, error) {
 		create := action.(core.CreateAction)
 		return true, create.GetObject(), nil
@@ -232,7 +237,6 @@ func TestStatefulPodControlCreatePodFailed(t *testing.T) {
 
 	} else if !strings.Contains(events[1], v1.EventTypeWarning) {
 		t.Errorf("Found unexpected non-warning event %s", events[1])
-
 	}
 }
 
@@ -241,7 +245,14 @@ func TestStatefulPodControlNoOpUpdate(t *testing.T) {
 	set := newStatefulSet(3)
 	pod := newStatefulSetPod(set, 0)
 	fakeClient := &fake.Clientset{}
-	control := NewRealStatefulPodControl(fakeClient, nil, nil, nil, recorder)
+	claims := getPersistentVolumeClaims(set, pod)
+	indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+	for k := range claims {
+		claim := claims[k]
+		indexer.Add(&claim)
+	}
+	claimLister := corelisters.NewPersistentVolumeClaimLister(indexer)
+	control := NewStatefulPodControl(fakeClient, nil, claimLister, recorder)
 	fakeClient.AddReactor("*", "*", func(action core.Action) (bool, runtime.Object, error) {
 		t.Error("no-op update should not make any client invocation")
 		return true, nil, apierrors.NewInternalError(errors.New("if we are here we have a problem"))
@@ -260,7 +271,9 @@ func TestStatefulPodControlUpdatesIdentity(t *testing.T) {
 	set := newStatefulSet(3)
 	pod := newStatefulSetPod(set, 0)
 	fakeClient := fake.NewSimpleClientset(set, pod)
-	control := NewRealStatefulPodControl(fakeClient, nil, nil, nil, recorder)
+	indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+	claimLister := corelisters.NewPersistentVolumeClaimLister(indexer)
+	control := NewStatefulPodControl(fakeClient, nil, claimLister, recorder)
 	var updated *v1.Pod
 	fakeClient.PrependReactor("update", "pods", func(action core.Action) (bool, runtime.Object, error) {
 		update := action.(core.UpdateAction)
@@ -287,12 +300,14 @@ func TestStatefulPodControlUpdateIdentityFailure(t *testing.T) {
 	set := newStatefulSet(3)
 	pod := newStatefulSetPod(set, 0)
 	fakeClient := &fake.Clientset{}
-	indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+	podIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
 	gooPod := newStatefulSetPod(set, 0)
 	gooPod.Name = "goo-0"
-	indexer.Add(gooPod)
-	podLister := corelisters.NewPodLister(indexer)
-	control := NewRealStatefulPodControl(fakeClient, nil, podLister, nil, recorder)
+	podIndexer.Add(gooPod)
+	podLister := corelisters.NewPodLister(podIndexer)
+	claimIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+	claimLister := corelisters.NewPersistentVolumeClaimLister(claimIndexer)
+	control := NewStatefulPodControl(fakeClient, podLister, claimLister, recorder)
 	fakeClient.AddReactor("update", "pods", func(action core.Action) (bool, runtime.Object, error) {
 		pod.Name = "goo-0"
 		return true, nil, apierrors.NewInternalError(errors.New("API server down"))
@@ -319,7 +334,7 @@ func TestStatefulPodControlUpdatesPodStorage(t *testing.T) {
 	fakeClient := &fake.Clientset{}
 	pvcIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
 	pvcLister := corelisters.NewPersistentVolumeClaimLister(pvcIndexer)
-	control := NewRealStatefulPodControl(fakeClient, nil, nil, pvcLister, recorder)
+	control := NewStatefulPodControl(fakeClient, nil, pvcLister, recorder)
 	pvcs := getPersistentVolumeClaims(set, pod)
 	volumes := make([]v1.Volume, 0, len(pod.Spec.Volumes))
 	for i := range pod.Spec.Volumes {
@@ -366,7 +381,7 @@ func TestStatefulPodControlUpdatePodStorageFailure(t *testing.T) {
 	fakeClient := &fake.Clientset{}
 	pvcIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
 	pvcLister := corelisters.NewPersistentVolumeClaimLister(pvcIndexer)
-	control := NewRealStatefulPodControl(fakeClient, nil, nil, pvcLister, recorder)
+	control := NewStatefulPodControl(fakeClient, nil, pvcLister, recorder)
 	pvcs := getPersistentVolumeClaims(set, pod)
 	volumes := make([]v1.Volume, 0, len(pod.Spec.Volumes))
 	for i := range pod.Spec.Volumes {
@@ -401,12 +416,19 @@ func TestStatefulPodControlUpdatePodConflictSuccess(t *testing.T) {
 	set := newStatefulSet(3)
 	pod := newStatefulSetPod(set, 0)
 	fakeClient := &fake.Clientset{}
-	indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+	podIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+	podLister := corelisters.NewPodLister(podIndexer)
+	claimIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+	claimLister := corelisters.NewPersistentVolumeClaimLister(podIndexer)
 	gooPod := newStatefulSetPod(set, 0)
-	gooPod.Name = "goo-0"
-	indexer.Add(gooPod)
-	podLister := corelisters.NewPodLister(indexer)
-	control := NewRealStatefulPodControl(fakeClient, nil, podLister, nil, recorder)
+	gooPod.Labels[apps.StatefulSetPodNameLabel] = "goo-starts"
+	podIndexer.Add(gooPod)
+	claims := getPersistentVolumeClaims(set, gooPod)
+	for k := range claims {
+		claim := claims[k]
+		claimIndexer.Add(&claim)
+	}
+	control := NewStatefulPodControl(fakeClient, podLister, claimLister, recorder)
 	conflict := false
 	fakeClient.AddReactor("update", "pods", func(action core.Action) (bool, runtime.Object, error) {
 		update := action.(core.UpdateAction)
@@ -417,7 +439,7 @@ func TestStatefulPodControlUpdatePodConflictSuccess(t *testing.T) {
 		return true, update.GetObject(), nil
 
 	})
-	pod.Name = "goo-0"
+	pod.Labels[apps.StatefulSetPodNameLabel] = "goo-0"
 	if err := control.UpdateStatefulPod(set, pod); err != nil {
 		t.Errorf("Successful update returned an error: %s", err)
 	}
@@ -437,7 +459,7 @@ func TestStatefulPodControlDeletesStatefulPod(t *testing.T) {
 	set := newStatefulSet(3)
 	pod := newStatefulSetPod(set, 0)
 	fakeClient := &fake.Clientset{}
-	control := NewRealStatefulPodControl(fakeClient, nil, nil, nil, recorder)
+	control := NewStatefulPodControl(fakeClient, nil, nil, recorder)
 	fakeClient.AddReactor("delete", "pods", func(action core.Action) (bool, runtime.Object, error) {
 		return true, nil, nil
 	})
@@ -457,7 +479,7 @@ func TestStatefulPodControlDeleteFailure(t *testing.T) {
 	set := newStatefulSet(3)
 	pod := newStatefulSetPod(set, 0)
 	fakeClient := &fake.Clientset{}
-	control := NewRealStatefulPodControl(fakeClient, nil, nil, nil, recorder)
+	control := NewStatefulPodControl(fakeClient, nil, nil, recorder)
 	fakeClient.AddReactor("delete", "pods", func(action core.Action) (bool, runtime.Object, error) {
 		return true, nil, apierrors.NewInternalError(errors.New("API server down"))
 	})
@@ -472,6 +494,344 @@ func TestStatefulPodControlDeleteFailure(t *testing.T) {
 	}
 }
 
+func TestStatefulPodControlClaimsMatchDeletionPolcy(t *testing.T) {
+	// The claimOwnerMatchesSetAndPod is tested exhaustively in stateful_set_utils_test; this
+	// test is for the wiring to the method tested there.
+	fakeClient := &fake.Clientset{}
+	indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+	claimLister := corelisters.NewPersistentVolumeClaimLister(indexer)
+	set := newStatefulSet(3)
+	pod := newStatefulSetPod(set, 0)
+	claims := getPersistentVolumeClaims(set, pod)
+	for k := range claims {
+		claim := claims[k]
+		indexer.Add(&claim)
+	}
+	control := NewStatefulPodControl(fakeClient, nil, claimLister, &noopRecorder{})
+	set.Spec.PersistentVolumeClaimRetentionPolicy = &apps.StatefulSetPersistentVolumeClaimRetentionPolicy{
+		WhenDeleted: apps.RetainPersistentVolumeClaimRetentionPolicyType,
+		WhenScaled:  apps.RetainPersistentVolumeClaimRetentionPolicyType,
+	}
+	if matches, err := control.ClaimsMatchRetentionPolicy(set, pod); err != nil {
+		t.Errorf("Unexpected error for ClaimsMatchRetentionPolicy (retain): %v", err)
+	} else if !matches {
+		t.Error("Unexpected non-match for ClaimsMatchRetentionPolicy (retain)")
+	}
+	set.Spec.PersistentVolumeClaimRetentionPolicy = &apps.StatefulSetPersistentVolumeClaimRetentionPolicy{
+		WhenDeleted: apps.DeletePersistentVolumeClaimRetentionPolicyType,
+		WhenScaled:  apps.RetainPersistentVolumeClaimRetentionPolicyType,
+	}
+	if matches, err := control.ClaimsMatchRetentionPolicy(set, pod); err != nil {
+		t.Errorf("Unexpected error for ClaimsMatchRetentionPolicy (set deletion): %v", err)
+	} else if matches {
+		t.Error("Unexpected match for ClaimsMatchRetentionPolicy (set deletion)")
+	}
+}
+
+func TestStatefulPodControlUpdatePodClaimForRetentionPolicy(t *testing.T) {
+	// All the update conditions are tested exhaustively in stateful_set_utils_test. This
+	// tests the wiring from the pod control to that method.
+	testFn := func(t *testing.T) {
+		defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.StatefulSetAutoDeletePVC, true)()
+		fakeClient := &fake.Clientset{}
+		indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+		claimLister := corelisters.NewPersistentVolumeClaimLister(indexer)
+		set := newStatefulSet(3)
+		set.GetObjectMeta().SetUID("set-123")
+		pod := newStatefulSetPod(set, 0)
+		claims := getPersistentVolumeClaims(set, pod)
+		for k := range claims {
+			claim := claims[k]
+			indexer.Add(&claim)
+		}
+		control := NewStatefulPodControl(fakeClient, nil, claimLister, &noopRecorder{})
+		set.Spec.PersistentVolumeClaimRetentionPolicy = &apps.StatefulSetPersistentVolumeClaimRetentionPolicy{
+			WhenDeleted: apps.DeletePersistentVolumeClaimRetentionPolicyType,
+			WhenScaled:  apps.RetainPersistentVolumeClaimRetentionPolicyType,
+		}
+		if err := control.UpdatePodClaimForRetentionPolicy(set, pod); err != nil {
+			t.Errorf("Unexpected error for UpdatePodClaimForRetentionPolicy (retain): %v", err)
+		}
+		expectRef := utilfeature.DefaultFeatureGate.Enabled(features.StatefulSetAutoDeletePVC)
+		for k := range claims {
+			claim, err := claimLister.PersistentVolumeClaims(claims[k].Namespace).Get(claims[k].Name)
+			if err != nil {
+				t.Errorf("Unexpected error getting Claim %s/%s: %v", claim.Namespace, claim.Name, err)
+			}
+			if hasOwnerRef(claim, set) != expectRef {
+				t.Errorf("Claim %s/%s bad set owner ref", claim.Namespace, claim.Name)
+			}
+		}
+	}
+	t.Run("StatefulSetAutoDeletePVCEnabled", func(t *testing.T) {
+		defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.StatefulSetAutoDeletePVC, true)()
+		testFn(t)
+	})
+	t.Run("StatefulSetAutoDeletePVCDisabled", func(t *testing.T) {
+		defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.StatefulSetAutoDeletePVC, false)()
+		testFn(t)
+	})
+}
+
+func TestPodClaimIsStale(t *testing.T) {
+	const missing = "missing"
+	const exists = "exists"
+	const stale = "stale"
+	const withRef = "with-ref"
+	testCases := []struct {
+		name        string
+		claimStates []string
+		expected    bool
+		skipPodUID  bool
+	}{
+		{
+			name:        "all missing",
+			claimStates: []string{missing, missing},
+			expected:    false,
+		},
+		{
+			name:        "no claims",
+			claimStates: []string{},
+			expected:    false,
+		},
+		{
+			name:        "exists",
+			claimStates: []string{missing, exists},
+			expected:    false,
+		},
+		{
+			name:        "all refs",
+			claimStates: []string{withRef, withRef},
+			expected:    false,
+		},
+		{
+			name:        "stale & exists",
+			claimStates: []string{stale, exists},
+			expected:    true,
+		},
+		{
+			name:        "stale & missing",
+			claimStates: []string{stale, missing},
+			expected:    true,
+		},
+		{
+			name:        "withRef & stale",
+			claimStates: []string{withRef, stale},
+			expected:    true,
+		},
+		{
+			name:        "withRef, no UID",
+			claimStates: []string{withRef},
+			skipPodUID:  true,
+			expected:    true,
+		},
+	}
+	for _, tc := range testCases {
+		set := apps.StatefulSet{}
+		set.Name = "set"
+		set.Namespace = "default"
+		set.Spec.PersistentVolumeClaimRetentionPolicy = &apps.StatefulSetPersistentVolumeClaimRetentionPolicy{
+			WhenDeleted: apps.RetainPersistentVolumeClaimRetentionPolicyType,
+			WhenScaled:  apps.DeletePersistentVolumeClaimRetentionPolicyType,
+		}
+		set.Spec.Selector = &metav1.LabelSelector{MatchLabels: map[string]string{"key": "value"}}
+		claimIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+		for i, claimState := range tc.claimStates {
+			claim := v1.PersistentVolumeClaim{}
+			claim.Name = fmt.Sprintf("claim-%d", i)
+			set.Spec.VolumeClaimTemplates = append(set.Spec.VolumeClaimTemplates, claim)
+			claim.Name = fmt.Sprintf("%s-set-3", claim.Name)
+			claim.Namespace = set.Namespace
+			switch claimState {
+			case missing:
+			// Do nothing, the claim shouldn't exist.
+			case exists:
+				claimIndexer.Add(&claim)
+			case stale:
+				claim.SetOwnerReferences([]metav1.OwnerReference{
+					{Name: "set-3", UID: types.UID("stale")},
+				})
+				claimIndexer.Add(&claim)
+			case withRef:
+				claim.SetOwnerReferences([]metav1.OwnerReference{
+					{Name: "set-3", UID: types.UID("123")},
+				})
+				claimIndexer.Add(&claim)
+			}
+		}
+		pod := v1.Pod{}
+		pod.Name = "set-3"
+		if !tc.skipPodUID {
+			pod.SetUID("123")
+		}
+		claimLister := corelisters.NewPersistentVolumeClaimLister(claimIndexer)
+		control := NewStatefulPodControl(&fake.Clientset{}, nil, claimLister, &noopRecorder{})
+		expected := tc.expected
+		// Note that the error isn't / can't be tested.
+		if stale, _ := control.PodClaimIsStale(&set, &pod); stale != expected {
+			t.Errorf("unexpected stale for %s", tc.name)
+		}
+	}
+}
+
+func TestStatefulPodControlRetainDeletionPolicyUpdate(t *testing.T) {
+	testFn := func(t *testing.T) {
+		recorder := record.NewFakeRecorder(10)
+		set := newStatefulSet(1)
+		set.Spec.PersistentVolumeClaimRetentionPolicy = &apps.StatefulSetPersistentVolumeClaimRetentionPolicy{
+			WhenDeleted: apps.RetainPersistentVolumeClaimRetentionPolicyType,
+			WhenScaled:  apps.RetainPersistentVolumeClaimRetentionPolicyType,
+		}
+		pod := newStatefulSetPod(set, 0)
+		fakeClient := &fake.Clientset{}
+		podIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+		podLister := corelisters.NewPodLister(podIndexer)
+		claimIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+		claimLister := corelisters.NewPersistentVolumeClaimLister(claimIndexer)
+		podIndexer.Add(pod)
+		claims := getPersistentVolumeClaims(set, pod)
+		if len(claims) < 1 {
+			t.Errorf("Unexpected missing PVCs")
+		}
+		for k := range claims {
+			claim := claims[k]
+			setOwnerRef(&claim, set, &set.TypeMeta) // This ownerRef should be removed in the update.
+			claimIndexer.Add(&claim)
+		}
+		control := NewStatefulPodControl(fakeClient, podLister, claimLister, recorder)
+		if err := control.UpdateStatefulPod(set, pod); err != nil {
+			t.Errorf("Successful update returned an error: %s", err)
+		}
+		for k := range claims {
+			claim := claims[k]
+			if hasOwnerRef(&claim, set) {
+				t.Errorf("ownerRef not removed: %s/%s", claim.Namespace, claim.Name)
+			}
+		}
+		events := collectEvents(recorder.Events)
+		if utilfeature.DefaultFeatureGate.Enabled(features.StatefulSetAutoDeletePVC) {
+			if eventCount := len(events); eventCount != 1 {
+				t.Errorf("delete failed: got %d events, but want 1", eventCount)
+			}
+		} else {
+			if len(events) != 0 {
+				t.Errorf("delete failed: expected no events, but got %v", events)
+			}
+		}
+	}
+	t.Run("StatefulSetAutoDeletePVCEnabled", func(t *testing.T) {
+		defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.StatefulSetAutoDeletePVC, true)()
+		testFn(t)
+	})
+	t.Run("StatefulSetAutoDeletePVCDisabled", func(t *testing.T) {
+		defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.StatefulSetAutoDeletePVC, false)()
+		testFn(t)
+	})
+}
+
+func TestStatefulPodControlRetentionPolicyUpdate(t *testing.T) {
+	// Only applicable when the feature gate is on; the off case is tested in TestStatefulPodControlRetainRetentionPolicyUpdate.
+	defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.StatefulSetAutoDeletePVC, true)()
+
+	recorder := record.NewFakeRecorder(10)
+	set := newStatefulSet(1)
+	set.Spec.PersistentVolumeClaimRetentionPolicy = &apps.StatefulSetPersistentVolumeClaimRetentionPolicy{
+		WhenDeleted: apps.DeletePersistentVolumeClaimRetentionPolicyType,
+		WhenScaled:  apps.RetainPersistentVolumeClaimRetentionPolicyType,
+	}
+	pod := newStatefulSetPod(set, 0)
+	fakeClient := &fake.Clientset{}
+	podIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+	claimIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+	podIndexer.Add(pod)
+	claims := getPersistentVolumeClaims(set, pod)
+	if len(claims) != 1 {
+		t.Errorf("Unexpected or missing PVCs")
+	}
+	var claim v1.PersistentVolumeClaim
+	for k := range claims {
+		claim = claims[k]
+		claimIndexer.Add(&claim)
+	}
+	fakeClient.AddReactor("update", "persistentvolumeclaims", func(action core.Action) (bool, runtime.Object, error) {
+		update := action.(core.UpdateAction)
+		claimIndexer.Update(update.GetObject())
+		return true, update.GetObject(), nil
+	})
+	podLister := corelisters.NewPodLister(podIndexer)
+	claimLister := corelisters.NewPersistentVolumeClaimLister(claimIndexer)
+	control := NewStatefulPodControl(fakeClient, podLister, claimLister, recorder)
+	if err := control.UpdateStatefulPod(set, pod); err != nil {
+		t.Errorf("Successful update returned an error: %s", err)
+	}
+	updatedClaim, err := claimLister.PersistentVolumeClaims(claim.Namespace).Get(claim.Name)
+	if err != nil {
+		t.Errorf("Error retrieving claim %s/%s: %v", claim.Namespace, claim.Name, err)
+	}
+	if !hasOwnerRef(updatedClaim, set) {
+		t.Errorf("ownerRef not added: %s/%s", claim.Namespace, claim.Name)
+	}
+	events := collectEvents(recorder.Events)
+	if eventCount := len(events); eventCount != 1 {
+		t.Errorf("update failed: got %d events, but want 1", eventCount)
+	}
+}
+
+func TestStatefulPodControlRetentionPolicyUpdateMissingClaims(t *testing.T) {
+	// Only applicable when the feature gate is on.
+	defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.StatefulSetAutoDeletePVC, true)()
+
+	recorder := record.NewFakeRecorder(10)
+	set := newStatefulSet(1)
+	set.Spec.PersistentVolumeClaimRetentionPolicy = &apps.StatefulSetPersistentVolumeClaimRetentionPolicy{
+		WhenDeleted: apps.DeletePersistentVolumeClaimRetentionPolicyType,
+		WhenScaled:  apps.RetainPersistentVolumeClaimRetentionPolicyType,
+	}
+	pod := newStatefulSetPod(set, 0)
+	fakeClient := &fake.Clientset{}
+	podIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+	podLister := corelisters.NewPodLister(podIndexer)
+	claimIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
+	claimLister := corelisters.NewPersistentVolumeClaimLister(claimIndexer)
+	podIndexer.Add(pod)
+	fakeClient.AddReactor("update", "persistentvolumeclaims", func(action core.Action) (bool, runtime.Object, error) {
+		update := action.(core.UpdateAction)
+		claimIndexer.Update(update.GetObject())
+		return true, update.GetObject(), nil
+	})
+	control := NewStatefulPodControl(fakeClient, podLister, claimLister, recorder)
+	if err := control.UpdateStatefulPod(set, pod); err != nil {
+		t.Error("Unexpected error on pod update when PVCs are missing")
+	}
+	claims := getPersistentVolumeClaims(set, pod)
+	if len(claims) != 1 {
+		t.Errorf("Unexpected or missing PVCs")
+	}
+	var claim v1.PersistentVolumeClaim
+	for k := range claims {
+		claim = claims[k]
+		claimIndexer.Add(&claim)
+	}
+
+	if err := control.UpdateStatefulPod(set, pod); err != nil {
+		t.Errorf("Expected update to succeed, saw error %v", err)
+	}
+	updatedClaim, err := claimLister.PersistentVolumeClaims(claim.Namespace).Get(claim.Name)
+	if err != nil {
+		t.Errorf("Error retrieving claim %s/%s: %v", claim.Namespace, claim.Name, err)
+	}
+	if !hasOwnerRef(updatedClaim, set) {
+		t.Errorf("ownerRef not added: %s/%s", claim.Namespace, claim.Name)
+	}
+	events := collectEvents(recorder.Events)
+	if eventCount := len(events); eventCount != 1 {
+		t.Errorf("update failed: got %d events, but want 2", eventCount)
+	}
+	if !strings.Contains(events[0], "SuccessfulUpdate") {
+		t.Errorf("expected first event to be a successful update: %s", events[1])
+	}
+}
+
 func collectEvents(source <-chan string) []string {
 	done := false
 	events := make([]string, 0)