upstream/kubernetes
1
0
Fork 0
mirror of https://github.com/kubernetes/kubernetes.git synced 2026-05-28 04:04:39 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Migrate all storage tests to use request info

Browse source
This commit is contained in:
Joe Betz 2026-05-13 11:10:47 -04:00
parent 1717cbdae8
commit 10685fb246
No known key found for this signature in database
GPG key ID: 1E2BA7FEB91911CB
22 changed files with 184 additions and 176 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
pkg/registry/apps/daemonset/storage/storage_test.go
View file

@ -25,7 +25,6 @@ import (
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -189,7 +188,8 @@ func TestUpdateStatus(t *testing.T) {
defer storage.Store.DestroyFunc()
dsStart := newValidDaemonSet()
ctx := genericapirequest.WithNamespace(genericapirequest.NewDefaultContext(), dsStart.Namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, dsStart.Namespace)
statusCtx := genericregistrytest.NewNamespaceScopeContext(storage.Store, dsStart.Namespace, "status")
key, _ := storage.KeyFunc(ctx, dsStart.Name)
err := storage.Storage.Create(ctx, key, dsStart, nil, 0, false)
if err != nil {
@ -198,7 +198,7 @@ func TestUpdateStatus(t *testing.T) {
ds := dsStart.DeepCopy()
ds.Status.ObservedGeneration = 1
_, _, err = statusStorage.Update(ctx, ds.Name, rest.DefaultUpdatedObjectInfo(ds), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err = statusStorage.Update(statusCtx, ds.Name, rest.DefaultUpdatedObjectInfo(ds), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}

49
pkg/registry/apps/deployment/storage/storage_test.go
View file

@ -33,7 +33,6 @@ import (
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/util/intstr"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -200,7 +199,8 @@ func TestScaleGet(t *testing.T) {
defer server.Terminate(t)
defer storage.Deployment.Store.DestroyFunc()
var deployment apps.Deployment
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Deployment.Store, namespace)
scaleCtx := genericregistrytest.NewNamespaceScopeContext(storage.Deployment.Store, namespace, "scale")
key := "/deployments/" + namespace + "/" + name
if err := storage.Deployment.Storage.Create(ctx, key, &validDeployment, &deployment, 0, false); err != nil {
t.Fatalf("error setting new deployment (key: %s) %v: %v", key, validDeployment, err)
@ -226,7 +226,7 @@ func TestScaleGet(t *testing.T) {
Selector: selector.String(),
},
}
obj, err := storage.Scale.Get(ctx, name, &metav1.GetOptions{})
obj, err := storage.Scale.Get(scaleCtx, name, &metav1.GetOptions{})
if err != nil {
t.Fatalf("error fetching scale for %s: %v", name, err)
}
@ -241,7 +241,8 @@ func TestScaleUpdate(t *testing.T) {
defer server.Terminate(t)
defer storage.Deployment.Store.DestroyFunc()
var deployment apps.Deployment
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Deployment.Store, namespace)
scaleCtx := genericregistrytest.NewNamespaceScopeContext(storage.Deployment.Store, namespace, "scale")
key := "/deployments/" + namespace + "/" + name
if err := storage.Deployment.Storage.Create(ctx, key, &validDeployment, &deployment, 0, false); err != nil {
t.Fatalf("error setting new deployment (key: %s) %v: %v", key, validDeployment, err)
@ -254,10 +255,10 @@ func TestScaleUpdate(t *testing.T) {
},
}
if _, _, err := storage.Scale.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
if _, _, err := storage.Scale.Update(scaleCtx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
t.Fatalf("error updating scale %v: %v", update, err)
}
obj, err := storage.Scale.Get(ctx, name, &metav1.GetOptions{})
obj, err := storage.Scale.Get(scaleCtx, name, &metav1.GetOptions{})
if err != nil {
t.Fatalf("error fetching scale for %s: %v", name, err)
}
@ -269,7 +270,7 @@ func TestScaleUpdate(t *testing.T) {
update.ResourceVersion = deployment.ResourceVersion
update.Spec.Replicas = 15
if _, _, err = storage.Scale.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil && !apierrors.IsConflict(err) {
if _, _, err = storage.Scale.Update(scaleCtx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil && !apierrors.IsConflict(err) {
t.Fatalf("unexpected error, expecting an update conflict but got %v", err)
}
}
@ -278,7 +279,8 @@ func TestStatusUpdate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
defer storage.Deployment.Store.DestroyFunc()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Deployment.Store, namespace)
statusCtx := genericregistrytest.NewNamespaceScopeContext(storage.Deployment.Store, namespace, "status")
key := "/deployments/" + namespace + "/" + name
if err := storage.Deployment.Storage.Create(ctx, key, &validDeployment, nil, 0, false); err != nil {
t.Fatalf("unexpected error: %v", err)
@ -293,7 +295,7 @@ func TestStatusUpdate(t *testing.T) {
},
}
if _, _, err := storage.Status.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
if _, _, err := storage.Status.Update(statusCtx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
t.Fatalf("unexpected error: %v", err)
}
obj, err := storage.Deployment.Get(ctx, name, &metav1.GetOptions{})
@ -345,12 +347,13 @@ func TestEtcdCreateDeploymentRollback(t *testing.T) {
rollbackStorage := storage.Rollback
deployment := validNewDeployment()
deployment.Namespace = fmt.Sprintf("namespace-%s", strings.ToLower(k))
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), deployment.Namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Deployment.Store, deployment.Namespace)
rollbackCtx := genericregistrytest.NewNamespaceScopeContext(storage.Deployment.Store, deployment.Namespace, "rollback")
if _, err := storage.Deployment.Create(ctx, deployment, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}); err != nil {
t.Fatalf("%s: unexpected error: %v", k, err)
}
rollbackRespStatus, err := rollbackStorage.Create(ctx, test.rollback.Name, &test.rollback, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
rollbackRespStatus, err := rollbackStorage.Create(rollbackCtx, test.rollback.Name, &test.rollback, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if !test.errOK(err) {
t.Errorf("%s: unexpected error: %v", k, err)
} else if err == nil {
@ -381,7 +384,8 @@ func TestCreateDeploymentRollbackValidation(t *testing.T) {
RollbackTo: apps.RollbackConfig{Revision: 1},
}
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Deployment.Store, namespace)
rollbackCtx := genericregistrytest.NewNamespaceScopeContext(storage.Deployment.Store, namespace, "rollback")
if _, err := storage.Deployment.Create(ctx, validNewDeployment(), rest.ValidateAllObjectFunc, &metav1.CreateOptions{}); err != nil {
t.Fatalf("Unexpected error: %v", err)
@ -389,7 +393,7 @@ func TestCreateDeploymentRollbackValidation(t *testing.T) {
validationError := fmt.Errorf("admission deny")
alwaysDenyValidationFunc := func(ctx context.Context, obj runtime.Object) error { return validationError }
_, err := rollbackStorage.Create(ctx, rollback.Name, &rollback, alwaysDenyValidationFunc, &metav1.CreateOptions{})
_, err := rollbackStorage.Create(rollbackCtx, rollback.Name, &rollback, alwaysDenyValidationFunc, &metav1.CreateOptions{})
if err == nil || validationError != err {
t.Errorf("expected: %v, got: %v", validationError, err)
@ -406,9 +410,10 @@ func TestEtcdCreateDeploymentRollbackNoDeployment(t *testing.T) {
defer server.Terminate(t)
defer storage.Deployment.Store.DestroyFunc()
rollbackStorage := storage.Rollback
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Deployment.Store, namespace)
rollbackCtx := genericregistrytest.NewNamespaceScopeContext(storage.Deployment.Store, namespace, "rollback")
_, err := rollbackStorage.Create(ctx, name, &apps.DeploymentRollback{
_, err := rollbackStorage.Create(rollbackCtx, name, &apps.DeploymentRollback{
Name: name,
UpdatedAnnotations: map[string]string{},
RollbackTo: apps.RollbackConfig{Revision: 1},
@ -453,7 +458,8 @@ func TestScalePatchErrors(t *testing.T) {
scaleStore := storage.Scale
defer resourceStore.DestroyFunc()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Deployment.Store, namespace)
scaleCtx := genericregistrytest.NewNamespaceScopeContext(storage.Deployment.Store, namespace, "scale")
{
applyNotFoundPatch := func() rest.TransformFunc {
@ -462,7 +468,7 @@ func TestScalePatchErrors(t *testing.T) {
return currentObject, nil
}
}
_, _, err := scaleStore.Update(ctx, "bad-name", rest.DefaultUpdatedObjectInfo(nil, applyNotFoundPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err := scaleStore.Update(scaleCtx, "bad-name", rest.DefaultUpdatedObjectInfo(nil, applyNotFoundPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if !apierrors.IsNotFound(err) {
t.Errorf("expected notfound, got %v", err)
}
@ -479,7 +485,7 @@ func TestScalePatchErrors(t *testing.T) {
return currentObject, nil
}
}
_, _, err := scaleStore.Update(ctx, name, rest.DefaultUpdatedObjectInfo(nil, applyBadUIDPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err := scaleStore.Update(scaleCtx, name, rest.DefaultUpdatedObjectInfo(nil, applyBadUIDPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if !apierrors.IsConflict(err) {
t.Errorf("expected conflict, got %v", err)
}
@ -492,7 +498,7 @@ func TestScalePatchErrors(t *testing.T) {
return currentObject, nil
}
}
_, _, err := scaleStore.Update(ctx, name, rest.DefaultUpdatedObjectInfo(nil, applyBadResourceVersionPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err := scaleStore.Update(scaleCtx, name, rest.DefaultUpdatedObjectInfo(nil, applyBadResourceVersionPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if !apierrors.IsConflict(err) {
t.Errorf("expected conflict, got %v", err)
}
@ -507,7 +513,8 @@ func TestScalePatchConflicts(t *testing.T) {
scaleStore := storage.Scale
defer resourceStore.DestroyFunc()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Deployment.Store, namespace)
scaleCtx := genericregistrytest.NewNamespaceScopeContext(storage.Deployment.Store, namespace, "scale")
if _, err := resourceStore.Create(ctx, validObj, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
@ -552,7 +559,7 @@ func TestScalePatchConflicts(t *testing.T) {
}
}
for i := 0; i < 100; i++ {
result, _, err := scaleStore.Update(ctx, name, rest.DefaultUpdatedObjectInfo(nil, applyReplicaPatch(i)), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
result, _, err := scaleStore.Update(scaleCtx, name, rest.DefaultUpdatedObjectInfo(nil, applyReplicaPatch(i)), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if err != nil {
t.Fatalf("error patching scale: %v", err)
}

38
pkg/registry/apps/replicaset/storage/storage_test.go
View file

@ -29,7 +29,6 @@ import (
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -55,7 +54,7 @@ func newStorage(t *testing.T) (*ReplicaSetStorage, *etcd3testing.EtcdTestServer)
// createReplicaSet is a helper function that returns a ReplicaSet with the updated resource version.
func createReplicaSet(storage *REST, rs apps.ReplicaSet, t *testing.T) (apps.ReplicaSet, error) {
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), rs.Namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, rs.Namespace)
obj, err := storage.Create(ctx, &rs, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err != nil {
t.Errorf("Failed to create ReplicaSet, %v", err)
@ -152,7 +151,7 @@ func TestGenerationNumber(t *testing.T) {
modifiedSno := *validNewReplicaSet()
modifiedSno.Generation = 100
modifiedSno.Status.ObservedGeneration = 10
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.ReplicaSet.Store, metav1.NamespaceDefault)
rs, err := createReplicaSet(storage.ReplicaSet, modifiedSno, t)
if err != nil {
t.Errorf("unexpected error: %v", err)
@ -254,7 +253,8 @@ func TestScaleGet(t *testing.T) {
name := "foo"
var rs apps.ReplicaSet
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.ReplicaSet.Store, metav1.NamespaceDefault)
scaleCtx := genericregistrytest.NewNamespaceScopeContext(storage.ReplicaSet.Store, metav1.NamespaceDefault, "scale")
key := "/replicasets/" + metav1.NamespaceDefault + "/" + name
if err := storage.ReplicaSet.Storage.Create(ctx, key, &validReplicaSet, &rs, 0, false); err != nil {
t.Fatalf("error setting new replica set (key: %s) %v: %v", key, validReplicaSet, err)
@ -281,7 +281,7 @@ func TestScaleGet(t *testing.T) {
Selector: selector.String(),
},
}
obj, err := storage.Scale.Get(ctx, name, &metav1.GetOptions{})
obj, err := storage.Scale.Get(scaleCtx, name, &metav1.GetOptions{})
got := obj.(*autoscaling.Scale)
if err != nil {
t.Fatalf("error fetching scale for %s: %v", name, err)
@ -299,7 +299,8 @@ func TestScaleUpdate(t *testing.T) {
name := "foo"
var rs apps.ReplicaSet
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.ReplicaSet.Store, metav1.NamespaceDefault)
scaleCtx := genericregistrytest.NewNamespaceScopeContext(storage.ReplicaSet.Store, metav1.NamespaceDefault, "scale")
key := "/replicasets/" + metav1.NamespaceDefault + "/" + name
if err := storage.ReplicaSet.Storage.Create(ctx, key, &validReplicaSet, &rs, 0, false); err != nil {
t.Fatalf("error setting new replica set (key: %s) %v: %v", key, validReplicaSet, err)
@ -315,11 +316,11 @@ func TestScaleUpdate(t *testing.T) {
},
}
if _, _, err := storage.Scale.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
if _, _, err := storage.Scale.Update(scaleCtx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
t.Fatalf("error updating scale %v: %v", update, err)
}
obj, err := storage.Scale.Get(ctx, name, &metav1.GetOptions{})
obj, err := storage.Scale.Get(scaleCtx, name, &metav1.GetOptions{})
if err != nil {
t.Fatalf("error fetching scale for %s: %v", name, err)
}
@ -331,7 +332,7 @@ func TestScaleUpdate(t *testing.T) {
update.ResourceVersion = rs.ResourceVersion
update.Spec.Replicas = 15
if _, _, err = storage.Scale.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil && !apierrors.IsConflict(err) {
if _, _, err = storage.Scale.Update(scaleCtx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil && !apierrors.IsConflict(err) {
t.Fatalf("unexpected error, expecting an update conflict but got %v", err)
}
}
@ -341,7 +342,8 @@ func TestStatusUpdate(t *testing.T) {
defer server.Terminate(t)
defer storage.ReplicaSet.Store.DestroyFunc()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.ReplicaSet.Store, metav1.NamespaceDefault)
statusCtx := genericregistrytest.NewNamespaceScopeContext(storage.ReplicaSet.Store, metav1.NamespaceDefault, "status")
key := "/replicasets/" + metav1.NamespaceDefault + "/foo"
if err := storage.ReplicaSet.Storage.Create(ctx, key, &validReplicaSet, nil, 0, false); err != nil {
t.Fatalf("unexpected error: %v", err)
@ -356,7 +358,7 @@ func TestStatusUpdate(t *testing.T) {
},
}
if _, _, err := storage.Status.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
if _, _, err := storage.Status.Update(statusCtx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
t.Fatalf("unexpected error: %v", err)
}
obj, err := storage.ReplicaSet.Get(ctx, "foo", &metav1.GetOptions{})
@ -399,7 +401,8 @@ func TestScalePatchErrors(t *testing.T) {
scaleStore := storage.Scale
defer resourceStore.DestroyFunc()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(resourceStore, namespace)
scaleCtx := genericregistrytest.NewNamespaceScopeContext(resourceStore, namespace, "scale")
{
applyNotFoundPatch := func() rest.TransformFunc {
@ -408,7 +411,7 @@ func TestScalePatchErrors(t *testing.T) {
return currentObject, nil
}
}
_, _, err := scaleStore.Update(ctx, "bad-name", rest.DefaultUpdatedObjectInfo(nil, applyNotFoundPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err := scaleStore.Update(scaleCtx, "bad-name", rest.DefaultUpdatedObjectInfo(nil, applyNotFoundPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if !apierrors.IsNotFound(err) {
t.Errorf("expected notfound, got %v", err)
}
@ -425,7 +428,7 @@ func TestScalePatchErrors(t *testing.T) {
return currentObject, nil
}
}
_, _, err := scaleStore.Update(ctx, name, rest.DefaultUpdatedObjectInfo(nil, applyBadUIDPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err := scaleStore.Update(scaleCtx, name, rest.DefaultUpdatedObjectInfo(nil, applyBadUIDPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if !apierrors.IsConflict(err) {
t.Errorf("expected conflict, got %v", err)
}
@ -438,7 +441,7 @@ func TestScalePatchErrors(t *testing.T) {
return currentObject, nil
}
}
_, _, err := scaleStore.Update(ctx, name, rest.DefaultUpdatedObjectInfo(nil, applyBadResourceVersionPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err := scaleStore.Update(scaleCtx, name, rest.DefaultUpdatedObjectInfo(nil, applyBadResourceVersionPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if !apierrors.IsConflict(err) {
t.Errorf("expected conflict, got %v", err)
}
@ -455,7 +458,8 @@ func TestScalePatchConflicts(t *testing.T) {
scaleStore := storage.Scale
defer resourceStore.DestroyFunc()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(resourceStore, namespace)
scaleCtx := genericregistrytest.NewNamespaceScopeContext(resourceStore, namespace, "scale")
if _, err := resourceStore.Create(ctx, validObj, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
@ -500,7 +504,7 @@ func TestScalePatchConflicts(t *testing.T) {
}
}
for i := 0; i < 100; i++ {
result, _, err := scaleStore.Update(ctx, name, rest.DefaultUpdatedObjectInfo(nil, applyReplicaPatch(i)), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
result, _, err := scaleStore.Update(scaleCtx, name, rest.DefaultUpdatedObjectInfo(nil, applyReplicaPatch(i)), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if err != nil {
t.Fatalf("error patching scale: %v", err)
}

34
pkg/registry/apps/statefulset/storage/storage_test.go
View file

@ -29,7 +29,6 @@ import (
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -109,7 +108,8 @@ func TestStatusUpdate(t *testing.T) {
storage, server := newStorage(t)
defer server.Terminate(t)
defer storage.StatefulSet.Store.DestroyFunc()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.StatefulSet.Store, metav1.NamespaceDefault)
statusCtx := genericregistrytest.NewNamespaceScopeContext(storage.StatefulSet.Store, metav1.NamespaceDefault, "status")
key := "/statefulsets/" + metav1.NamespaceDefault + "/foo"
validStatefulSet := validNewStatefulSet()
if err := storage.StatefulSet.Storage.Create(ctx, key, validStatefulSet, nil, 0, false); err != nil {
@ -125,7 +125,7 @@ func TestStatusUpdate(t *testing.T) {
},
}
if _, _, err := storage.Status.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
if _, _, err := storage.Status.Update(statusCtx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
t.Fatalf("unexpected error: %v", err)
}
obj, err := storage.StatefulSet.Get(ctx, "foo", &metav1.GetOptions{})
@ -218,7 +218,8 @@ func TestScaleGet(t *testing.T) {
name := "foo"
var sts apps.StatefulSet
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.StatefulSet.Store, metav1.NamespaceDefault)
scaleCtx := genericregistrytest.NewNamespaceScopeContext(storage.StatefulSet.Store, metav1.NamespaceDefault, "scale")
key := "/statefulsets/" + metav1.NamespaceDefault + "/" + name
if err := storage.StatefulSet.Storage.Create(ctx, key, &validStatefulSet, &sts, 0, false); err != nil {
t.Fatalf("error setting new statefulset (key: %s) %v: %v", key, validStatefulSet, err)
@ -244,7 +245,7 @@ func TestScaleGet(t *testing.T) {
Selector: selector.String(),
},
}
obj, err := storage.Scale.Get(ctx, name, &metav1.GetOptions{})
obj, err := storage.Scale.Get(scaleCtx, name, &metav1.GetOptions{})
got := obj.(*autoscaling.Scale)
if err != nil {
t.Fatalf("error fetching scale for %s: %v", name, err)
@ -262,7 +263,8 @@ func TestScaleUpdate(t *testing.T) {
name := "foo"
var sts apps.StatefulSet
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.StatefulSet.Store, metav1.NamespaceDefault)
scaleCtx := genericregistrytest.NewNamespaceScopeContext(storage.StatefulSet.Store, metav1.NamespaceDefault, "scale")
key := "/statefulsets/" + metav1.NamespaceDefault + "/" + name
if err := storage.StatefulSet.Storage.Create(ctx, key, &validStatefulSet, &sts, 0, false); err != nil {
t.Fatalf("error setting new statefulset (key: %s) %v: %v", key, validStatefulSet, err)
@ -278,11 +280,11 @@ func TestScaleUpdate(t *testing.T) {
},
}
if _, _, err := storage.Scale.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
if _, _, err := storage.Scale.Update(scaleCtx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
t.Fatalf("error updating scale %v: %v", update, err)
}
obj, err := storage.Scale.Get(ctx, name, &metav1.GetOptions{})
obj, err := storage.Scale.Get(scaleCtx, name, &metav1.GetOptions{})
if err != nil {
t.Fatalf("error fetching scale for %s: %v", name, err)
}
@ -294,7 +296,7 @@ func TestScaleUpdate(t *testing.T) {
update.ResourceVersion = sts.ResourceVersion
update.Spec.Replicas = 15
if _, _, err = storage.Scale.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil && !apierrors.IsConflict(err) {
if _, _, err = storage.Scale.Update(scaleCtx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil && !apierrors.IsConflict(err) {
t.Fatalf("unexpected error, expecting an update conflict but got %v", err)
}
}
@ -311,7 +313,8 @@ func TestScalePatchErrors(t *testing.T) {
scaleStore := storage.Scale
defer resourceStore.DestroyFunc()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(resourceStore, namespace)
scaleCtx := genericregistrytest.NewNamespaceScopeContext(resourceStore, namespace, "scale")
{
applyNotFoundPatch := func() rest.TransformFunc {
@ -320,7 +323,7 @@ func TestScalePatchErrors(t *testing.T) {
return currentObject, nil
}
}
_, _, err := scaleStore.Update(ctx, "bad-name", rest.DefaultUpdatedObjectInfo(nil, applyNotFoundPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err := scaleStore.Update(scaleCtx, "bad-name", rest.DefaultUpdatedObjectInfo(nil, applyNotFoundPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if !apierrors.IsNotFound(err) {
t.Errorf("expected notfound, got %v", err)
}
@ -337,7 +340,7 @@ func TestScalePatchErrors(t *testing.T) {
return currentObject, nil
}
}
_, _, err := scaleStore.Update(ctx, name, rest.DefaultUpdatedObjectInfo(nil, applyBadUIDPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err := scaleStore.Update(scaleCtx, name, rest.DefaultUpdatedObjectInfo(nil, applyBadUIDPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if !apierrors.IsConflict(err) {
t.Errorf("expected conflict, got %v", err)
}
@ -350,7 +353,7 @@ func TestScalePatchErrors(t *testing.T) {
return currentObject, nil
}
}
_, _, err := scaleStore.Update(ctx, name, rest.DefaultUpdatedObjectInfo(nil, applyBadResourceVersionPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err := scaleStore.Update(scaleCtx, name, rest.DefaultUpdatedObjectInfo(nil, applyBadResourceVersionPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if !apierrors.IsConflict(err) {
t.Errorf("expected conflict, got %v", err)
}
@ -367,7 +370,8 @@ func TestScalePatchConflicts(t *testing.T) {
scaleStore := storage.Scale
defer resourceStore.DestroyFunc()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(resourceStore, namespace)
scaleCtx := genericregistrytest.NewNamespaceScopeContext(resourceStore, namespace, "scale")
if _, err := resourceStore.Create(ctx, validObj, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
@ -412,7 +416,7 @@ func TestScalePatchConflicts(t *testing.T) {
}
}
for i := 0; i < 100; i++ {
result, _, err := scaleStore.Update(ctx, name, rest.DefaultUpdatedObjectInfo(nil, applyReplicaPatch(i)), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
result, _, err := scaleStore.Update(scaleCtx, name, rest.DefaultUpdatedObjectInfo(nil, applyReplicaPatch(i)), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if err != nil {
t.Fatalf("error patching scale: %v", err)
}

5
pkg/registry/batch/job/storage/storage_test.go
View file

@ -197,7 +197,6 @@ func TestJobDeletion(t *testing.T) {
orphanDeletionPropagation := metav1.DeletePropagationOrphan
backgroundDeletionPropagation := metav1.DeletePropagationBackground
job := validNewV1Job()
ctx := genericapirequest.NewDefaultContext()
key := "/jobs/" + metav1.NamespaceDefault + "/foo"
tests := []struct {
description string
@ -291,7 +290,9 @@ func TestJobDeletion(t *testing.T) {
defer server.Terminate(t)
defer storage.Job.Store.DestroyFunc()
dc := dummyRecorder{agent: "", text: ""}
ctx = genericapirequest.WithRequestInfo(ctx, test.requestInfo)
ctx := genericapirequest.WithRequestInfo(
genericregistrytest.NewNamespaceScopeContext(storage.Job.Store, metav1.NamespaceDefault),
test.requestInfo)
ctxWithRecorder := warning.WithWarningRecorder(ctx, &dc)
// Create the object
if err := storage.Job.Storage.Create(ctxWithRecorder, key, job, nil, 0, false); err != nil {

6
pkg/registry/certificates/podcertificaterequest/storage/storage_test.go
View file

@ -242,7 +242,7 @@ func TestUpdateStatus(t *testing.T) {
defer server.Terminate(t)
defer statusStorage.store.DestroyFunc()
test := genericregistrytest.New(t, statusStorage.store)
test := genericregistrytest.New(t, statusStorage.store, "status")
test.SetUserInfo(&user.DefaultInfo{
Name: "foo",
})
@ -309,7 +309,7 @@ func TestUpdateStatusStompsSpec(t *testing.T) {
defer server.Terminate(t)
defer statusStorage.store.DestroyFunc()
test := genericregistrytest.New(t, statusStorage.store)
test := genericregistrytest.New(t, statusStorage.store, "status")
test.SetUserInfo(&user.DefaultInfo{
Name: "foo",
})
@ -355,7 +355,7 @@ func TestUpdateStatusFailsWhenAuthorizerDenies(t *testing.T) {
defer server.Terminate(t)
defer statusStorage.store.DestroyFunc()
test := genericregistrytest.New(t, statusStorage.store)
test := genericregistrytest.New(t, statusStorage.store, "status")
test.SetUserInfo(&user.DefaultInfo{
Name: "foo",
})

35
pkg/registry/core/namespace/storage/storage_test.go
View file

@ -24,7 +24,6 @@ import (
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -74,7 +73,7 @@ func TestCreateSetsFields(t *testing.T) {
defer server.Terminate(t)
defer storage.store.DestroyFunc()
namespace := validNewNamespace()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceNone)
ctx := genericregistrytest.NewClusterScopeContext(storage.store)
_, err := storage.Create(ctx, namespace, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err != nil {
t.Fatalf("unexpected error: %v", err)
@ -152,7 +151,7 @@ func TestDeleteNamespaceWithIncompleteFinalizers(t *testing.T) {
defer server.Terminate(t)
defer storage.store.DestroyFunc()
key := "/namespaces/foo"
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceNone)
ctx := genericregistrytest.NewClusterScopeContext(storage.store)
now := metav1.Now()
namespace := &api.Namespace{
ObjectMeta: metav1.ObjectMeta{
@ -167,7 +166,7 @@ func TestDeleteNamespaceWithIncompleteFinalizers(t *testing.T) {
if err := storage.store.Storage.Create(ctx, key, namespace, nil, 0, false); err != nil {
t.Fatalf("unexpected error: %v", err)
}
ctx = genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace.Name)
ctx = genericregistrytest.NewNamespaceScopeContext(storage.store, namespace.Name)
obj, immediate, err := storage.Delete(ctx, "foo", rest.ValidateAllObjectFunc, nil)
if err != nil {
t.Fatalf("unexpected error")
@ -189,7 +188,7 @@ func TestUpdateDeletingNamespaceWithIncompleteMetadataFinalizers(t *testing.T) {
defer server.Terminate(t)
defer storage.store.DestroyFunc()
key := "/namespaces/foo"
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceNone)
ctx := genericregistrytest.NewClusterScopeContext(storage.store)
now := metav1.Now()
namespace := &api.Namespace{
ObjectMeta: metav1.ObjectMeta{
@ -205,7 +204,7 @@ func TestUpdateDeletingNamespaceWithIncompleteMetadataFinalizers(t *testing.T) {
if err := storage.store.Storage.Create(ctx, key, namespace, nil, 0, false); err != nil {
t.Fatalf("unexpected error: %v", err)
}
ctx = genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace.Name)
ctx = genericregistrytest.NewNamespaceScopeContext(storage.store, namespace.Name)
ns, err := storage.Get(ctx, "foo", &metav1.GetOptions{})
if err != nil {
t.Fatalf("unexpected error: %v", err)
@ -225,7 +224,7 @@ func TestUpdateDeletingNamespaceWithIncompleteSpecFinalizers(t *testing.T) {
defer server.Terminate(t)
defer storage.store.DestroyFunc()
key := "/namespaces/foo"
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceNone)
ctx := genericregistrytest.NewClusterScopeContext(storage.store)
now := metav1.Now()
namespace := &api.Namespace{
ObjectMeta: metav1.ObjectMeta{
@ -244,7 +243,7 @@ func TestUpdateDeletingNamespaceWithIncompleteSpecFinalizers(t *testing.T) {
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
ctx = genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace.Name)
ctx = genericregistrytest.NewNamespaceScopeContext(storage.store, namespace.Name)
if _, _, err = storage.Update(ctx, "foo", rest.DefaultUpdatedObjectInfo(ns), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
t.Fatalf("unexpected error: %v", err)
}
@ -260,7 +259,7 @@ func TestUpdateDeletingNamespaceWithCompleteFinalizers(t *testing.T) {
defer server.Terminate(t)
defer storage.store.DestroyFunc()
key := "/namespaces/foo"
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceNone)
ctx := genericregistrytest.NewClusterScopeContext(storage.store)
now := metav1.Now()
namespace := &api.Namespace{
ObjectMeta: metav1.ObjectMeta{
@ -278,7 +277,7 @@ func TestUpdateDeletingNamespaceWithCompleteFinalizers(t *testing.T) {
t.Fatalf("unexpected error: %v", err)
}
ns.(*api.Namespace).Finalizers = nil
ctx = genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace.Name)
ctx = genericregistrytest.NewNamespaceScopeContext(storage.store, namespace.Name)
if _, _, err = storage.Update(ctx, "foo", rest.DefaultUpdatedObjectInfo(ns), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
t.Fatalf("unexpected error: %v", err)
}
@ -302,7 +301,7 @@ func TestFinalizeDeletingNamespaceWithCompleteFinalizers(t *testing.T) {
defer storage.store.DestroyFunc()
defer finalizeStorage.store.DestroyFunc()
key := "/namespaces/foo"
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceNone)
ctx := genericregistrytest.NewClusterScopeContext(storage.store)
now := metav1.Now()
namespace := &api.Namespace{
ObjectMeta: metav1.ObjectMeta{
@ -322,7 +321,7 @@ func TestFinalizeDeletingNamespaceWithCompleteFinalizers(t *testing.T) {
t.Fatalf("unexpected error: %v", err)
}
ns.(*api.Namespace).Spec.Finalizers = nil
ctx = genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace.Name)
ctx = genericregistrytest.NewNamespaceScopeContext(storage.store, namespace.Name)
if _, _, err = finalizeStorage.Update(ctx, "foo", rest.DefaultUpdatedObjectInfo(ns), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
t.Fatalf("unexpected error: %v", err)
}
@ -346,7 +345,7 @@ func TestFinalizeDeletingNamespaceWithIncompleteMetadataFinalizers(t *testing.T)
defer storage.store.DestroyFunc()
defer finalizeStorage.store.DestroyFunc()
key := "/namespaces/foo"
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceNone)
ctx := genericregistrytest.NewClusterScopeContext(storage.store)
now := metav1.Now()
namespace := &api.Namespace{
ObjectMeta: metav1.ObjectMeta{
@ -367,7 +366,7 @@ func TestFinalizeDeletingNamespaceWithIncompleteMetadataFinalizers(t *testing.T)
t.Fatalf("unexpected error: %v", err)
}
ns.(*api.Namespace).Spec.Finalizers = nil
ctx = genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace.Name)
ctx = genericregistrytest.NewNamespaceScopeContext(storage.store, namespace.Name)
if _, _, err = finalizeStorage.Update(ctx, "foo", rest.DefaultUpdatedObjectInfo(ns), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
t.Fatalf("unexpected error: %v", err)
}
@ -383,7 +382,7 @@ func TestDeleteNamespaceWithCompleteFinalizers(t *testing.T) {
defer server.Terminate(t)
defer storage.store.DestroyFunc()
key := "/namespaces/foo"
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceNone)
ctx := genericregistrytest.NewClusterScopeContext(storage.store)
now := metav1.Now()
namespace := &api.Namespace{
ObjectMeta: metav1.ObjectMeta{
@ -398,7 +397,7 @@ func TestDeleteNamespaceWithCompleteFinalizers(t *testing.T) {
if err := storage.store.Storage.Create(ctx, key, namespace, nil, 0, false); err != nil {
t.Fatalf("unexpected error: %v", err)
}
ctx = genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace.Name)
ctx = genericregistrytest.NewNamespaceScopeContext(storage.store, namespace.Name)
if _, _, err := storage.Delete(ctx, "foo", rest.ValidateAllObjectFunc, nil); err != nil {
t.Errorf("unexpected error: %v", err)
}
@ -586,7 +585,7 @@ func TestDeleteWithGCFinalizers(t *testing.T) {
for _, test := range tests {
key := "/namespaces/" + test.name
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceNone)
ctx := genericregistrytest.NewClusterScopeContext(storage.store)
namespace := &api.Namespace{
ObjectMeta: metav1.ObjectMeta{
Name: test.name,
@ -602,7 +601,7 @@ func TestDeleteWithGCFinalizers(t *testing.T) {
}
var obj runtime.Object
var err error
ctx = genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace.Name)
ctx = genericregistrytest.NewNamespaceScopeContext(storage.store, namespace.Name)
if obj, _, err = storage.Delete(ctx, test.name, rest.ValidateAllObjectFunc, test.deleteOptions); err != nil {
t.Fatalf("unexpected error: %v", err)
}

3
pkg/registry/core/node/storage/storage_test.go
View file

@ -25,7 +25,6 @@ import (
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -235,7 +234,7 @@ func TestResourceLocation(t *testing.T) {
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.WithNamespace(genericapirequest.NewDefaultContext(), fmt.Sprintf("namespace-%s", testCase.name))
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, fmt.Sprintf("namespace-%s", testCase.name))
key, _ := storage.KeyFunc(ctx, testCase.node.Name)
if err := storage.Storage.Create(ctx, key, testCase.node, nil, 0, false); err != nil {
t.Fatalf("unexpected error: %v", err)

6
pkg/registry/core/persistentvolume/storage/storage_test.go
View file

@ -28,7 +28,6 @@ import (
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -174,7 +173,8 @@ func TestUpdateStatus(t *testing.T) {
storage, statusStorage, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceNone)
ctx := genericregistrytest.NewClusterScopeContext(storage.Store)
statusCtx := genericregistrytest.NewClusterScopeContext(storage.Store, "status")
key, _ := storage.KeyFunc(ctx, "foo")
pvStart := validNewPersistentVolume("foo")
err := storage.Storage.Create(ctx, key, pvStart, nil, 0, false)
@ -201,7 +201,7 @@ func TestUpdateStatus(t *testing.T) {
},
}
_, _, err = statusStorage.Update(ctx, pvIn.Name, rest.DefaultUpdatedObjectInfo(pvIn), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err = statusStorage.Update(statusCtx, pvIn.Name, rest.DefaultUpdatedObjectInfo(pvIn), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}

6
pkg/registry/core/persistentvolumeclaim/storage/storage_test.go
View file

@ -27,7 +27,6 @@ import (
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -159,7 +158,8 @@ func TestUpdateStatus(t *testing.T) {
storage, statusStorage, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
statusCtx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault, "status")
key, _ := storage.KeyFunc(ctx, "foo")
pvcStart := validNewPersistentVolumeClaim("foo", metav1.NamespaceDefault)
@ -186,7 +186,7 @@ func TestUpdateStatus(t *testing.T) {
},
}
_, _, err = statusStorage.Update(ctx, pvc.Name, rest.DefaultUpdatedObjectInfo(pvc), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err = statusStorage.Update(statusCtx, pvc.Name, rest.DefaultUpdatedObjectInfo(pvc), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}

14
pkg/registry/core/pod/storage/eviction_test.go
View file

@ -36,6 +36,7 @@ import (
"k8s.io/apimachinery/pkg/util/validation/field"
"k8s.io/apimachinery/pkg/watch"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
"k8s.io/client-go/kubernetes/fake"
podapi "k8s.io/kubernetes/pkg/api/pod"
@ -176,10 +177,10 @@ func TestEvictionWithETCD(t *testing.T) {
pdbsCopy = append(pdbsCopy, pdbCopy)
}
testContext := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault)
storage, _, statusStorage, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
testContext := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
pod := validNewPod()
pod.Name = tc.podName
@ -632,7 +633,9 @@ func TestEviction(t *testing.T) {
pdbsCopy = append(pdbsCopy, pdbCopy)
}
testContext := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault)
testContext := genericapirequest.WithRequestInfo(
genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault),
&genericapirequest.RequestInfo{APIGroup: "", APIVersion: "v1", Resource: "pods"})
ms := &mockStore{
deleteCount: 0,
}
@ -731,10 +734,10 @@ func TestEvictionWithDeleteOptions(t *testing.T) {
for _, tc := range testcases {
t.Run(tc.name, func(t *testing.T) {
testContext := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault)
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
testContext := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
pod := validNewPod()
pod.Labels = map[string]string{"a": "true"}
@ -803,10 +806,10 @@ func TestEvictionPDBStatus(t *testing.T) {
for _, tc := range testcases {
t.Run(tc.name, func(t *testing.T) {
testContext := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault)
storage, _, statusStorage, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
testContext := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
client := fake.NewSimpleClientset(tc.pdb)
for _, podName := range []string{"foo-1", "foo-2"} {
@ -903,11 +906,10 @@ func TestAddConditionAndDelete(t *testing.T) {
},
}
testContext := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault)
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
testContext := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
client := fake.NewSimpleClientset()
evictionRest := newEvictionStorage(storage.Store, client.PolicyV1())

37
pkg/registry/core/pod/storage/storage_test.go
View file

@ -173,11 +173,11 @@ func newFailDeleteStorage(t *testing.T, called *bool) (*REST, *etcd3testing.Etcd
func TestIgnoreDeleteNotFound(t *testing.T) {
pod := validNewPod()
testContext := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault)
called := false
registry, server := newFailDeleteStorage(t, &called)
defer server.Terminate(t)
defer registry.Store.DestroyFunc()
testContext := genericregistrytest.NewNamespaceScopeContext(registry.Store, metav1.NamespaceDefault)
// should fail if pod A is not created yet.
_, _, err := registry.Delete(testContext, pod.Name, rest.ValidateAllObjectFunc, nil)
@ -223,11 +223,11 @@ func TestCreateSetsFields(t *testing.T) {
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
pod := validNewPod()
_, err := storage.Create(genericapirequest.NewDefaultContext(), pod, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
_, err := storage.Create(ctx, pod, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
ctx := genericapirequest.NewDefaultContext()
object, err := storage.Get(ctx, "foo", &metav1.GetOptions{})
if err != nil {
t.Errorf("unexpected error: %v", err)
@ -379,7 +379,7 @@ func TestResourceLocation(t *testing.T) {
defer server.Terminate(t)
for i, tc := range testCases {
// unique namespace/storage location per test
ctx := genericapirequest.WithNamespace(genericapirequest.NewDefaultContext(), fmt.Sprintf("namespace-%d", i))
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, fmt.Sprintf("namespace-%d", i))
key, _ := storage.KeyFunc(ctx, tc.pod.Name)
if err := storage.Storage.Create(ctx, key, &tc.pod, nil, 0, false); err != nil {
t.Fatalf("unexpected error: %v", err)
@ -451,7 +451,7 @@ func TestConvertToTableList(t *testing.T) {
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
columns := []metav1.TableColumnDefinition{
{Name: "Name", Type: "string", Format: "name", Description: metav1.ObjectMeta{}.SwaggerDoc()["name"]},
@ -603,7 +603,7 @@ func TestEtcdCreate(t *testing.T) {
storage, bindingStorage, _, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
_, err := storage.Create(ctx, validNewPod(), rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err != nil {
t.Fatalf("unexpected error: %v", err)
@ -633,7 +633,7 @@ func TestEtcdCreateClearsNominatedNodeName(t *testing.T) {
storage, bindingStorage, statusStorage, server := newStorage(t)
defer server.Terminate(t)
defer storage.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
pod := validNewPod()
created, err := storage.Create(ctx, pod, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
@ -687,7 +687,7 @@ func TestEtcdCreateBindingNoPod(t *testing.T) {
storage, bindingStorage, _, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
// Assume that a pod has undergone the following:
// - Create (apiserver)
@ -730,7 +730,7 @@ func TestEtcdCreateWithContainersNotFound(t *testing.T) {
storage, bindingStorage, _, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
_, err := storage.Create(ctx, validNewPod(), rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err != nil {
t.Fatalf("unexpected error: %v", err)
@ -769,7 +769,7 @@ func TestEtcdCreateWithConflict(t *testing.T) {
storage, bindingStorage, _, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
_, err := storage.Create(ctx, validNewPod(), rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err != nil {
@ -822,7 +822,7 @@ func TestEtcdCreateWithSchedulingGates(t *testing.T) {
storage, bindingStorage, _, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
pod := validNewPod()
pod.Spec.SchedulingGates = tt.schedulingGates
@ -952,7 +952,7 @@ func TestEtcdCreateBindingWithUIDAndResourceVersion(t *testing.T) {
for k, testCase := range testCases {
pod := validNewPod()
pod.Namespace = fmt.Sprintf("namespace-%s", strings.ToLower(k))
ctx := genericapirequest.WithNamespace(genericapirequest.NewDefaultContext(), pod.Namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, pod.Namespace)
podCreated, err := storage.Create(ctx, pod, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err != nil {
@ -979,7 +979,7 @@ func TestEtcdCreateWithExistingContainers(t *testing.T) {
storage, bindingStorage, _, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
_, err := storage.Create(ctx, validNewPod(), rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err != nil {
t.Fatalf("unexpected error: %v", err)
@ -1050,7 +1050,7 @@ func TestEtcdCreateBinding(t *testing.T) {
for k, test := range testCases {
pod := validNewPod()
pod.Namespace = fmt.Sprintf("namespace-%s", strings.ToLower(k))
ctx := genericapirequest.WithNamespace(genericapirequest.NewDefaultContext(), pod.Namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, pod.Namespace)
if _, err := storage.Create(ctx, pod, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}); err != nil {
t.Fatalf("%s: unexpected error: %v", k, err)
}
@ -1076,7 +1076,7 @@ func TestEtcdUpdateNotScheduled(t *testing.T) {
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
if _, err := storage.Create(ctx, validNewPod(), rest.ValidateAllObjectFunc, &metav1.CreateOptions{}); err != nil {
t.Fatalf("unexpected error: %v", err)
@ -1102,7 +1102,7 @@ func TestEtcdUpdateScheduled(t *testing.T) {
storage, _, _, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
key, _ := storage.KeyFunc(ctx, "foo")
err := storage.Storage.Create(ctx, key, &api.Pod{
@ -1176,7 +1176,8 @@ func TestEtcdUpdateStatus(t *testing.T) {
storage, _, statusStorage, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
statusCtx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault, "status")
key, _ := storage.KeyFunc(ctx, "foo")
podStart := api.Pod{
@ -1269,7 +1270,7 @@ func TestEtcdUpdateStatus(t *testing.T) {
expected.Labels = podIn.Labels
expected.Status = podIn.Status
_, _, err = statusStorage.Update(ctx, podIn.Name, rest.DefaultUpdatedObjectInfo(&podIn), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err = statusStorage.Update(statusCtx, podIn.Name, rest.DefaultUpdatedObjectInfo(&podIn), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}

40
pkg/registry/core/replicationcontroller/storage/storage_test.go
View file

@ -30,7 +30,6 @@ import (
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -64,10 +63,7 @@ func newStorage(t *testing.T) (ControllerStorage, *etcd3testing.EtcdTestServer)
// createController is a helper function that returns a controller with the updated resource version.
func createController(storage *REST, rc api.ReplicationController, t *testing.T) (api.ReplicationController, error) {
ctx := genericapirequest.WithRequestInfo(
genericapirequest.WithNamespace(genericapirequest.NewContext(), rc.Namespace),
&genericapirequest.RequestInfo{APIGroup: "", APIVersion: "v1"},
)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, rc.Namespace)
obj, err := storage.Create(ctx, &rc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err != nil {
t.Errorf("Failed to create controller, %v", err)
@ -161,7 +157,7 @@ func TestGenerationNumber(t *testing.T) {
modifiedSno := *validNewController()
modifiedSno.Generation = 100
modifiedSno.Status.ObservedGeneration = 10
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Controller.Store, metav1.NamespaceDefault)
rc, err := createController(storage.Controller, modifiedSno, t)
if err != nil {
t.Errorf("unexpected error: %v", err)
@ -260,7 +256,7 @@ func TestUpdateStatus(t *testing.T) {
defer server.Terminate(t)
defer storage.Controller.Store.Destroy()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
statusCtx := genericregistrytest.NewNamespaceScopeContext(storage.Controller.Store, namespace, "status")
rcStart, err := createController(storage.Controller, *validController, t)
if err != nil {
t.Fatalf("error setting new replication controller %v: %v", *validController, err)
@ -268,11 +264,11 @@ func TestUpdateStatus(t *testing.T) {
rc := rcStart.DeepCopy()
rc.Status.Replicas++
_, _, err = storage.Status.Update(ctx, rc.Name, rest.DefaultUpdatedObjectInfo(rc), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err = storage.Status.Update(statusCtx, rc.Name, rest.DefaultUpdatedObjectInfo(rc), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}
obj, err := storage.Status.Get(ctx, rc.Name, &metav1.GetOptions{})
obj, err := storage.Status.Get(statusCtx, rc.Name, &metav1.GetOptions{})
if err != nil {
t.Errorf("unexpected error: %v", err)
}
@ -288,7 +284,7 @@ func TestScaleGet(t *testing.T) {
defer server.Terminate(t)
defer storage.Controller.Store.DestroyFunc()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
scaleCtx := genericregistrytest.NewNamespaceScopeContext(storage.Controller.Store, namespace, "scale")
rc, err := createController(storage.Controller, *validController, t)
if err != nil {
t.Fatalf("error setting new replication controller %v: %v", *validController, err)
@ -310,7 +306,7 @@ func TestScaleGet(t *testing.T) {
Selector: labels.SelectorFromSet(validController.Spec.Template.Labels).String(),
},
}
obj, err := storage.Scale.Get(ctx, name, &metav1.GetOptions{})
obj, err := storage.Scale.Get(scaleCtx, name, &metav1.GetOptions{})
if err != nil {
t.Fatalf("error fetching scale for %s: %v", name, err)
}
@ -325,7 +321,7 @@ func TestScaleUpdate(t *testing.T) {
defer server.Terminate(t)
defer storage.Controller.Store.DestroyFunc()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
scaleCtx := genericregistrytest.NewNamespaceScopeContext(storage.Controller.Store, namespace, "scale")
rc, err := createController(storage.Controller, *validController, t)
if err != nil {
t.Fatalf("error setting new replication controller %v: %v", *validController, err)
@ -338,10 +334,10 @@ func TestScaleUpdate(t *testing.T) {
},
}
if _, _, err := storage.Scale.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
if _, _, err := storage.Scale.Update(scaleCtx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
t.Fatalf("error updating scale %v: %v", update, err)
}
obj, err := storage.Scale.Get(ctx, name, &metav1.GetOptions{})
obj, err := storage.Scale.Get(scaleCtx, name, &metav1.GetOptions{})
if err != nil {
t.Fatalf("error fetching scale for %s: %v", name, err)
}
@ -353,7 +349,7 @@ func TestScaleUpdate(t *testing.T) {
update.ResourceVersion = rc.ResourceVersion
update.Spec.Replicas = 15
if _, _, err = storage.Scale.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil && !errors.IsConflict(err) {
if _, _, err = storage.Scale.Update(scaleCtx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil && !errors.IsConflict(err) {
t.Fatalf("unexpected error, expecting an update conflict but got %v", err)
}
}
@ -382,7 +378,8 @@ func TestScalePatchErrors(t *testing.T) {
scaleStore := storage.Scale
defer resourceStore.DestroyFunc()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Controller.Store, namespace)
scaleCtx := genericregistrytest.NewNamespaceScopeContext(storage.Controller.Store, namespace, "scale")
{
applyNotFoundPatch := func() rest.TransformFunc {
@ -391,7 +388,7 @@ func TestScalePatchErrors(t *testing.T) {
return currentObject, nil
}
}
_, _, err := scaleStore.Update(ctx, "bad-name", rest.DefaultUpdatedObjectInfo(nil, applyNotFoundPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err := scaleStore.Update(scaleCtx, "bad-name", rest.DefaultUpdatedObjectInfo(nil, applyNotFoundPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if !errors.IsNotFound(err) {
t.Errorf("expected notfound, got %v", err)
}
@ -408,7 +405,7 @@ func TestScalePatchErrors(t *testing.T) {
return currentObject, nil
}
}
_, _, err := scaleStore.Update(ctx, name, rest.DefaultUpdatedObjectInfo(nil, applyBadUIDPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err := scaleStore.Update(scaleCtx, name, rest.DefaultUpdatedObjectInfo(nil, applyBadUIDPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if !errors.IsConflict(err) {
t.Errorf("expected conflict, got %v", err)
}
@ -421,7 +418,7 @@ func TestScalePatchErrors(t *testing.T) {
return currentObject, nil
}
}
_, _, err := scaleStore.Update(ctx, name, rest.DefaultUpdatedObjectInfo(nil, applyBadResourceVersionPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err := scaleStore.Update(scaleCtx, name, rest.DefaultUpdatedObjectInfo(nil, applyBadResourceVersionPatch()), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if !errors.IsConflict(err) {
t.Errorf("expected conflict, got %v", err)
}
@ -436,7 +433,8 @@ func TestScalePatchConflicts(t *testing.T) {
scaleStore := storage.Scale
defer resourceStore.DestroyFunc()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Controller.Store, namespace)
scaleCtx := genericregistrytest.NewNamespaceScopeContext(storage.Controller.Store, namespace, "scale")
if _, err := resourceStore.Create(ctx, validObj, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
@ -481,7 +479,7 @@ func TestScalePatchConflicts(t *testing.T) {
}
}
for i := 0; i < 100; i++ {
result, _, err := scaleStore.Update(ctx, name, rest.DefaultUpdatedObjectInfo(nil, applyReplicaPatch(i)), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
result, _, err := scaleStore.Update(scaleCtx, name, rest.DefaultUpdatedObjectInfo(nil, applyReplicaPatch(i)), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if err != nil {
t.Fatalf("error patching scale: %v", err)
}

10
pkg/registry/core/resourcequota/storage/storage_test.go
View file

@ -25,7 +25,6 @@ import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -89,9 +88,9 @@ func TestCreateSetsFields(t *testing.T) {
storage, _, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
resourcequota := validNewResourceQuota()
_, err := storage.Create(genericapirequest.NewDefaultContext(), resourcequota, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
_, err := storage.Create(ctx, resourcequota, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
@ -161,7 +160,8 @@ func TestUpdateStatus(t *testing.T) {
storage, status, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
statusCtx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault, "status")
key, _ := storage.KeyFunc(ctx, "foo")
resourcequotaStart := validNewResourceQuota()
@ -195,7 +195,7 @@ func TestUpdateStatus(t *testing.T) {
},
}
_, _, err = status.Update(ctx, resourcequotaIn.Name, rest.DefaultUpdatedObjectInfo(resourcequotaIn), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err = status.Update(statusCtx, resourcequotaIn.Name, rest.DefaultUpdatedObjectInfo(resourcequotaIn), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}

33
pkg/registry/core/service/storage/storage_test.go
View file

@ -35,7 +35,6 @@ import (
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/util/intstr"
machineryutilnet "k8s.io/apimachinery/pkg/util/net"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -92,7 +91,7 @@ func newStorageWithPods(t *testing.T, ipFamilies []api.IPFamily, pods []api.Pod,
t.Fatalf("unexpected error from REST storage: %v", err)
}
if pods != nil && len(pods) > 0 {
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(podStorage.Pod.Store, metav1.NamespaceDefault)
for ix := range pods {
key, _ := podStorage.Pod.KeyFunc(ctx, pods[ix].Name)
if err := podStorage.Pod.Storage.Create(ctx, key, &pods[ix], nil, 0, false); err != nil {
@ -110,7 +109,7 @@ func newStorageWithPods(t *testing.T, ipFamilies []api.IPFamily, pods []api.Pod,
t.Fatalf("unexpected error from REST storage: %v", err)
}
if endpoints != nil && len(endpoints) > 0 {
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(endpointsStorage.Store, metav1.NamespaceDefault)
for ix := range endpoints {
key, _ := endpointsStorage.KeyFunc(ctx, endpoints[ix].Name)
if err := endpointsStorage.Store.Storage.Create(ctx, key, endpoints[ix], nil, 0, false); err != nil {
@ -800,7 +799,7 @@ func helpTestCreateUpdateDeleteWithFamilies(t *testing.T, testCases []cudTestCas
name += "__@L" + tc.line
}
t.Run(name, func(t *testing.T) {
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
// Create the object as specified and check the results.
obj, err := storage.Create(ctx, tc.create.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
@ -1399,7 +1398,7 @@ func TestCreateIgnoresIPsForExternalName(t *testing.T) {
itc.svc.Spec.Type = api.ServiceTypeExternalName
itc.svc.Spec.ExternalName = "example.com"
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
createdObj, err := storage.Create(ctx, itc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if itc.expectError && err != nil {
return
@ -1482,7 +1481,7 @@ func TestCreateInitClusterIPsFromClusterIP(t *testing.T) {
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
createdObj, err := storage.Create(ctx, tc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err != nil {
t.Fatalf("unexpected error creating service: %v", err)
@ -5941,7 +5940,7 @@ func TestCreateInitIPFields(t *testing.T) {
for _, itc := range otc.cases {
t.Run(itc.name+"__@L"+itc.line, func(t *testing.T) {
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
createdObj, err := storage.Create(ctx, itc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if itc.expectError && err != nil {
return
@ -6091,7 +6090,7 @@ func TestCreateInvalidClusterIPInputs(t *testing.T) {
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
_, err := storage.Create(ctx, tc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err == nil {
t.Fatalf("unexpected success creating service")
@ -6130,7 +6129,7 @@ func TestCreateDeleteReuse(t *testing.T) {
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
// Create it
createdObj, err := storage.Create(ctx, tc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
@ -6385,7 +6384,7 @@ func TestCreateInitNodePorts(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
createdObj, err := storage.Create(ctx, tc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if tc.expectError && err != nil {
return
@ -6499,7 +6498,7 @@ func TestCreateSkipsAllocationsForHeadless(t *testing.T) {
// This test is ONLY headless services.
tc.svc.Spec.ClusterIP = api.ClusterIPNone
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
createdObj, err := storage.Create(ctx, tc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if tc.expectError && err != nil {
return
@ -6568,7 +6567,7 @@ func TestCreateDryRun(t *testing.T) {
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
createdObj, err := storage.Create(ctx, tc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{DryRun: []string{metav1.DryRunAll}})
if err != nil {
t.Fatalf("unexpected error creating service: %v", err)
@ -6608,7 +6607,7 @@ func TestDeleteWithFinalizer(t *testing.T) {
s.Finalizers = []string{"example.com/test"}
})
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
// Create it with finalizer.
obj, err := storage.Create(ctx, svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
@ -6696,7 +6695,7 @@ func TestDeleteDryRun(t *testing.T) {
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
createdObj, err := storage.Create(ctx, tc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err != nil {
t.Fatalf("unexpected error creating service: %v", err)
@ -6793,7 +6792,7 @@ func TestUpdateDryRun(t *testing.T) {
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
obj, err := storage.Create(ctx, tc.svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err != nil {
t.Fatalf("unexpected error creating service: %v", err)
@ -11650,7 +11649,7 @@ func TestServiceRegistryResourceLocation(t *testing.T) {
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
for _, name := range []string{"unnamed", "unnamed2", "no-endpoints"} {
_, err := storage.Create(ctx,
svctest.MakeService(name,
@ -11840,7 +11839,7 @@ func TestUpdateServiceLoadBalancerStatus(t *testing.T) {
t.Run(tc.name, func(t *testing.T) {
svc := svctest.MakeService("foo", svctest.SetTypeLoadBalancer)
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
obj, err := storage.Create(ctx, svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err != nil {
t.Fatalf("created svc: %s", err)

6
pkg/registry/core/serviceaccount/storage/storage_test.go
View file

@ -29,7 +29,6 @@ import (
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apiserver/pkg/audit"
"k8s.io/apiserver/pkg/authentication/authenticator"
"k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -120,11 +119,8 @@ func TestCreate_Token_SetsCredentialIDAuditAnnotation(t *testing.T) {
// Enable JTI feature
featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.ServiceAccountTokenJTI, true)
ctx := context.Background()
// Create a test service account
serviceAccount := validNewServiceAccount("foo")
// add the namespace to the context as it is required
ctx = request.WithNamespace(ctx, serviceAccount.Namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, serviceAccount.Namespace)
_, err := storage.Store.Create(ctx, serviceAccount, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err != nil {
t.Fatalf("failed creating test service account: %v", err)

5
pkg/registry/core/serviceaccount/storage/token_test.go
View file

@ -33,6 +33,7 @@ import (
"k8s.io/apiserver/pkg/authentication/authenticator"
"k8s.io/apiserver/pkg/endpoints/request"
genericfeatures "k8s.io/apiserver/pkg/features"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
utilfeature "k8s.io/apiserver/pkg/util/feature"
"k8s.io/apiserver/pkg/warning"
@ -121,9 +122,7 @@ func TestCreate_Token_WithExpiryCap(t *testing.T) {
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := context.Background()
// add the namespace to the context as it is required
ctx = request.WithNamespace(ctx, serviceAccount.Namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, serviceAccount.Namespace)
// Enable ExternalServiceAccountTokenSigner feature
featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.ExternalServiceAccountTokenSigner, true)

6
pkg/registry/networking/ingress/storage/storage_test.go
View file

@ -26,7 +26,6 @@ import (
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/util/intstr"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -252,7 +251,8 @@ func TestUpdateStatus(t *testing.T) {
defer storage.Store.DestroyFunc()
ingStart := validIngress()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), namespace)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, namespace)
statusCtx := genericregistrytest.NewNamespaceScopeContext(storage.Store, namespace, "status")
key, _ := storage.KeyFunc(ctx, ingStart.Name)
err := storage.Storage.Create(ctx, key, ingStart, nil, 0, false)
if err != nil {
@ -265,7 +265,7 @@ func TestUpdateStatus(t *testing.T) {
IP: defaultLoadBalancer,
},
}
_, _, err = statusStorage.Update(ctx, ing.Name, rest.DefaultUpdatedObjectInfo(ing), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err = statusStorage.Update(statusCtx, ing.Name, rest.DefaultUpdatedObjectInfo(ing), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}

6
pkg/registry/policy/poddisruptionbudget/storage/storage_test.go
View file

@ -23,7 +23,6 @@ import (
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/util/intstr"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -78,7 +77,8 @@ func TestStatusUpdate(t *testing.T) {
storage, statusStorage, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.WithNamespace(genericapirequest.NewContext(), metav1.NamespaceDefault)
ctx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault)
statusCtx := genericregistrytest.NewNamespaceScopeContext(storage.Store, metav1.NamespaceDefault, "status")
key := "/poddisruptionbudgets/" + metav1.NamespaceDefault + "/foo"
validPodDisruptionBudget := validNewPodDisruptionBudget()
if err := storage.Storage.Create(ctx, key, validPodDisruptionBudget, nil, 0, false); err != nil {
@ -102,7 +102,7 @@ func TestStatusUpdate(t *testing.T) {
},
}
if _, _, err := statusStorage.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
if _, _, err := statusStorage.Update(statusCtx, update.Name, rest.DefaultUpdatedObjectInfo(&update), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{}); err != nil {
t.Fatalf("unexpected error: %v", err)
}
obj, err = storage.Get(ctx, "foo", &metav1.GetOptions{})

6
pkg/registry/resource/devicetaintrule/storage/storage_test.go
View file

@ -27,7 +27,6 @@ import (
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -154,7 +153,8 @@ func TestUpdateStatus(t *testing.T) {
storage, statusStorage, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewClusterScopeContext(storage.Store)
statusCtx := genericregistrytest.NewClusterScopeContext(storage.Store, "status")
key, _ := storage.KeyFunc(ctx, "foo")
deviceTaintStart := validNewDeviceTaint("foo")
@ -171,7 +171,7 @@ func TestUpdateStatus(t *testing.T) {
Message: "100 pods left",
LastTransitionTime: metav1.Time{Time: time.Now().Truncate(time.Second)},
}}
_, _, err = statusStorage.Update(ctx, deviceTaint.Name, rest.DefaultUpdatedObjectInfo(deviceTaint), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err = statusStorage.Update(statusCtx, deviceTaint.Name, rest.DefaultUpdatedObjectInfo(deviceTaint), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}

3
pkg/registry/scheduling/priorityclass/storage/storage_test.go
View file

@ -23,7 +23,6 @@ import (
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -118,7 +117,7 @@ func TestDeleteSystemPriorityClass(t *testing.T) {
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
key := "/priorityclasses/test/system-node-critical"
ctx := genericapirequest.NewContext()
ctx := genericregistrytest.NewClusterScopeContext(storage.Store)
pc := schedulingapiv1.SystemPriorityClasses()[0]
internalPc := &scheduling.PriorityClass{}
if err := schedulingapiv1.Convert_v1_PriorityClass_To_scheduling_PriorityClass(pc, internalPc, nil); err != nil {

6
pkg/registry/storage/volumeattachment/storage/storage_test.go
View file

@ -25,7 +25,6 @@ import (
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
@ -167,7 +166,8 @@ func TestEtcdStatusUpdate(t *testing.T) {
storage, statusStorage, server := newStorage(t)
defer server.Terminate(t)
defer storage.Store.DestroyFunc()
ctx := genericapirequest.NewDefaultContext()
ctx := genericregistrytest.NewClusterScopeContext(storage.Store)
statusCtx := genericregistrytest.NewClusterScopeContext(storage.Store, "status")
attachment := validNewVolumeAttachment("foo")
if _, err := storage.Create(ctx, attachment, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}); err != nil {
@ -182,7 +182,7 @@ func TestEtcdStatusUpdate(t *testing.T) {
attachmentIn := obj.(*storageapi.VolumeAttachment).DeepCopy()
attachmentIn.Status.Attached = true
_, _, err = statusStorage.Update(ctx, attachmentIn.Name, rest.DefaultUpdatedObjectInfo(attachmentIn), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
_, _, err = statusStorage.Update(statusCtx, attachmentIn.Name, rest.DefaultUpdatedObjectInfo(attachmentIn), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if err != nil {
t.Fatalf("Failed to update status: %v", err)
}