{
  "kind": "CreateOptions",
  "apiVersion": "v1",
  "dryRun": [
    "dryRunValue"
  ],
  "fieldManager": "fieldManagerValue",
  "fieldValidation": "fieldValidationValue"

apiVersion: v1
dryRun:
- dryRunValue
fieldManager: fieldManagerValue
fieldValidation: fieldValidationValue

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

	// add the namespace to the context as it is required
	ctx = request.WithNamespace(ctx, serviceAccount.Namespace)
	_, err := storage.Store.Create(ctx, serviceAccount, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
	if err != nil {
		t.Fatalf("failed creating test service account: %v", err)
	}

	// create an audit context to allow recording audit information
	ctx = audit.WithAuditContext(ctx)

	fmd, ok := fmg.(metadatafake.MetadataClient)
	if !ok {
		return
	}
	obj := &metav1.PartialObjectMetadata{
		TypeMeta:   crd.TypeMeta,
		ObjectMeta: crd.ObjectMeta,
	}
	if _, err := fmd.CreateFake(obj, metav1.CreateOptions{}); err != nil {
		if kerrors.IsAlreadyExists(err) {
			_, err = fmd.UpdateFake(obj, metav1.UpdateOptions{})
			if err != nil {
				t.Fatal(err)
			}
		} else {
			t.Fatal(err)
		}
	}

	_, err := client.CoreV1().ConfigMaps(ns).Create(context.Background(), &v1.ConfigMap{
		ObjectMeta: metav1.ObjectMeta{
			Name:      name,
			Namespace: ns,
		},
		Data: data,
	}, metav1.CreateOptions{})
	if err != nil {
		t.Fatal(err)
	}
	return data
}

func createNamespace(t *testing.T, client kubernetes.Interface, ns string, labels map[string]string) {
	t.Helper()

		return nil
	}
	newNs := &v1.Namespace{
		ObjectMeta: metav1.ObjectMeta{
			Name:      ns,
			Namespace: "",
		},
	}
	_, err := c.client.CoreV1().Namespaces().Create(context.TODO(), newNs, metav1.CreateOptions{})
	if err != nil && errors.IsAlreadyExists(err) {
		err = nil
	}
	return err

	for i, step := range steps {
		t.Run(fmt.Sprintf("[%v]", i), func(t *testing.T) {
			g := NewWithT(t)

			switch {
			case step.added != nil:
				_, err := cms.Create(context.TODO(), step.added, metav1.CreateOptions{})
				g.Expect(err).Should(BeNil())
			case step.updated != nil:
				_, err := cms.Update(context.TODO(), step.updated, metav1.UpdateOptions{})
				g.Expect(err).Should(BeNil())
			case step.deleted != nil:

			controller := NewController(systemNamespaces, clientset, namespaceInformer)

			clientset.PrependReactor("create", "namespaces", func(action k8stesting.Action) (bool, runtime.Object, error) {
				create := action.(k8stesting.CreateAction)
				namespaceInformer.Informer().GetIndexer().Add(create.GetObject())
				return true, create.GetObject(), nil
			})

			controller.sync()

			expectAction(t, clientset.Actions(), test.actions)

	Examples(namespace string) ExampleInterface
}

// ExampleInterface has methods to work with Example resources.
type ExampleInterface interface {
	Create(ctx context.Context, example *v1.Example, opts metav1.CreateOptions) (*v1.Example, error)
	Update(ctx context.Context, example *v1.Example, opts metav1.UpdateOptions) (*v1.Example, error)
	Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error