kubernetes/staging/src/k8s.io/apiserver/pkg/registry/generic/registry/store_test.go

var scheme

var codecs

func init() {}

type testGracefulStrategy

func (t testGracefulStrategy) CheckGracefulDelete(ctx context.Context, obj runtime.Object, options *metav1.DeleteOptions) bool {}

var _

type testOrphanDeleteStrategy

func (t *testOrphanDeleteStrategy) DefaultGarbageCollectionPolicy(ctx context.Context) rest.GarbageCollectionPolicy {}

type mutatingDeleteRESTStrategy

func (t *mutatingDeleteRESTStrategy) CheckGracefulDelete(ctx context.Context, obj runtime.Object, options *metav1.DeleteOptions) bool {}

type testRESTStrategy

func (t *testRESTStrategy) NamespaceScoped() bool          {}

func (t *testRESTStrategy) AllowCreateOnUpdate() bool      {}

func (t *testRESTStrategy) AllowUnconditionalUpdate() bool {}

func (t *testRESTStrategy) PrepareForCreate(ctx context.Context, obj runtime.Object) {}

func (t *testRESTStrategy) PrepareForUpdate(ctx context.Context, obj, old runtime.Object) {}

func (t *testRESTStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList {}

func (t *testRESTStrategy) WarningsOnCreate(ctx context.Context, obj runtime.Object) []string {}

func (t *testRESTStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) field.ErrorList {}

func (t *testRESTStrategy) WarningsOnUpdate(ctx context.Context, obj, old runtime.Object) []string {}

func (t *testRESTStrategy) Canonicalize(obj runtime.Object) {}

func NewTestGenericStoreRegistry(t *testing.T) (factory.DestroyFunc, *Store) {}

func getPodAttrs(obj runtime.Object) (labels.Set, fields.Set, error) {}

// matchPodName returns selection predicate that matches any pod with name in the set.
// Makes testing simpler.
func matchPodName(names ...string) storage.SelectionPredicate {}

func matchEverything() storage.SelectionPredicate {}

func TestStoreList(t *testing.T) {}

// TestStoreListResourceVersion tests that if List with ResourceVersion > 0, it will wait until
// the results are as fresh as given version.
func TestStoreListResourceVersion(t *testing.T) {}

func TestStoreCreate(t *testing.T) {}

type sequentialNameGenerator

func (m *sequentialNameGenerator) GenerateName(base string) string {}

func TestStoreCreateWithRetryNameGenerate(t *testing.T) {}

func TestStoreCreateWithRetryNameGenerateFeatureDisabled(t *testing.T) {}

func TestNewCreateOptionsFromUpdateOptions(t *testing.T) {}

func TestNewDeleteOptionsFromUpdateOptions(t *testing.T) {}

func TestStoreCreateHooks(t *testing.T) {}

func isQualifiedResource(err error, kind, group string) bool {}

func updateAndVerify(t *testing.T, ctx context.Context, registry *Store, pod *example.Pod) bool {}

func TestStoreUpdate(t *testing.T) {}

func TestNoOpUpdates(t *testing.T) {}

func TestStoreUpdateHooks(t *testing.T) {}

func TestStoreCreateOnUpdateHooks(t *testing.T) {}

func TestStoreUpdateHooksInnerRetry(t *testing.T) {}

func TestStoreGet(t *testing.T) {}

func TestStoreDelete(t *testing.T) {}

func TestStoreGracefulDeleteWithResourceVersion(t *testing.T) {}

// TestGracefulStoreCanDeleteIfExistingGracePeriodZero tests recovery from
// race condition where the graceful delete is unable to complete
// in prior operation, but the pod remains with deletion timestamp
// and grace period set to 0.
func TestGracefulStoreCanDeleteIfExistingGracePeriodZero(t *testing.T) {}

func TestGracefulStoreHandleFinalizers(t *testing.T) {}

func TestNonGracefulStoreHandleFinalizers(t *testing.T) {}

func TestStoreDeleteWithOrphanDependents(t *testing.T) {}

// Test the DeleteOptions.PropagationPolicy is handled correctly
func TestStoreDeletionPropagation(t *testing.T) {}

type storageWithCounter

func (s *storageWithCounter) GetList(ctx context.Context, key string, opts storage.ListOptions, listObj runtime.Object) error {}

func TestStoreDeleteCollection(t *testing.T) {}

func TestStoreDeleteCollectionNoMutateOptions(t *testing.T) {}

func TestStoreDeleteCollectionNotFound(t *testing.T) {}

func TestStoreDeleteCollectionWorkDistributorExited(t *testing.T) {}

func TestStoreDeleteCollectionWithContextCancellation(t *testing.T) {}

// Test whether objects deleted with DeleteCollection are correctly delivered
// to watchers.
func TestStoreDeleteCollectionWithWatch(t *testing.T) {}

func TestStoreWatch(t *testing.T) {}

func newTestGenericStoreRegistry(t *testing.T, scheme *runtime.Scheme, hasCacheEnabled bool) (factory.DestroyFunc, *Store) {}

func TestFinalizeDelete(t *testing.T) {}

func fakeRequestInfo(resource, apiGroup string) *genericapirequest.RequestInfo {}

func TestQualifiedResource(t *testing.T) {}

func denyCreateValidation(ctx context.Context, obj runtime.Object) error {}

func denyUpdateValidation(ctx context.Context, obj, old runtime.Object) error {}

type fakeStrategy

func (fakeStrategy) DefaultGarbageCollectionPolicy(ctx context.Context) rest.GarbageCollectionPolicy {}

func TestDeletionFinalizersForGarbageCollection(t *testing.T) {}

func TestMarkAsDeleting(t *testing.T) {}

type staleGuaranteedUpdateStorage

// GuaranteedUpdate overwrites the method with one that always suggests the cachedObj.
func (s *staleGuaranteedUpdateStorage) GuaranteedUpdate(
	ctx context.Context, key string, destination runtime.Object, ignoreNotFound bool,
	preconditions *storage.Preconditions, tryUpdate storage.UpdateFunc, _ runtime.Object) error {}

func TestDeleteWithCachedObject(t *testing.T) {}

func TestPreconditionalUpdateWithCachedObject(t *testing.T) {}

// TestRetryDeleteValidation checks if the deleteValidation is called again if
// the GuaranteedUpdate in the Delete handler conflicts with a simultaneous
// Update.
func TestRetryDeleteValidation(t *testing.T) {}

func emptyIndexFunc(obj interface{}

func TestValidateIndexers(t *testing.T) {}

type predictableNameGenerator

func (p *predictableNameGenerator) GenerateName(base string) string {}

func TestStoreCreateGenerateNameConflict(t *testing.T) {}