if Strategy.NamespaceScoped() {
		t.Errorf("ResourceClass must not be namespace scoped")
	}
	if Strategy.AllowCreateOnUpdate() {
		t.Errorf("ResourceClass should not allow create on update")
	}
}

func TestClassStrategyCreate(t *testing.T) {
	ctx := genericapirequest.NewDefaultContext()
	resourceClass := resourceClass.DeepCopy()

	Strategy.PrepareForCreate(ctx, resourceClass)
	errs := Strategy.Validate(ctx, resourceClass)

}

func (resourceClassStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList {
	resourceClass := obj.(*resource.ResourceClass)
	return validation.ValidateClass(resourceClass)
}

func (resourceClassStrategy) WarningsOnCreate(ctx context.Context, obj runtime.Object) []string {
	return nil
}

func (resourceClassStrategy) Canonicalize(obj runtime.Object) {
}

	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store)
	resourceClass := validNewResourceClassParameters("foo")
	resourceClass.ObjectMeta = metav1.ObjectMeta{}
	test.TestCreate(
		// valid
		resourceClass,
		// invalid
		&resource.ResourceClassParameters{
			ObjectMeta: metav1.ObjectMeta{Name: "*BadName!"},
		},
	)
}

	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store)
	resourceClass := validNewResourceClaimParameters("foo")
	resourceClass.ObjectMeta = metav1.ObjectMeta{}
	test.TestCreate(
		// valid
		resourceClass,
		// invalid
		&resource.ResourceClaimParameters{
			ObjectMeta: metav1.ObjectMeta{Name: "*BadName!"},
		},
	)
}

	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store).ClusterScope()
	resourceClass := validNewResourceSlice("foo")
	resourceClass.ObjectMeta = metav1.ObjectMeta{GenerateName: "foo"}
	test.TestCreate(
		// valid
		resourceClass,
		// invalid
		&resource.ResourceSlice{
			ObjectMeta: metav1.ObjectMeta{Name: "*BadName!"},
		},
	)
}

)

// REST implements a RESTStorage for ResourceClaimTemplate.
type REST struct {
	*genericregistry.Store
}

// NewREST returns a RESTStorage object that will work against ResourceClass.
func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, error) {
	store := &genericregistry.Store{
		NewFunc:                   func() runtime.Object { return &resource.ResourceClaimTemplate{} },

)

func addKnownTypes(scheme *runtime.Scheme) error {
	if err := scheme.AddIgnoredConversionType(&metav1.TypeMeta{}, &metav1.TypeMeta{}); err != nil {
		return err
	}
	scheme.AddKnownTypes(SchemeGroupVersion,
		&ResourceClass{},
		&ResourceClassList{},
		&ResourceClaim{},
		&ResourceClaimList{},
		&ResourceClaimTemplate{},
		&ResourceClaimTemplateList{},
		&PodSchedulingContext{},
		&PodSchedulingContextList{},
		&ResourceSlice{},

	AddToScheme   = SchemeBuilder.AddToScheme
)

// Adds the list of known types to the given scheme.
func addKnownTypes(scheme *runtime.Scheme) error {
	scheme.AddKnownTypes(SchemeGroupVersion,
		&ResourceClass{},
		&ResourceClassList{},
		&ResourceClaim{},
		&ResourceClaimList{},
		&ResourceClaimTemplate{},
		&ResourceClaimTemplateList{},
		&PodSchedulingContext{},
		&PodSchedulingContextList{},
		&ResourceSlice{},

SataQiu <******@****.***> 1702613527 +0800

Patrick Ohly <******@****.***> 1707917922 +0100