}
		if kc.ShutdownGracePeriod.Duration < 0 || (kc.ShutdownGracePeriod.Duration > 0 && kc.ShutdownGracePeriod.Duration < time.Second) {
			allErrors = append(allErrors, fmt.Errorf("invalid configuration: shutdownGracePeriod %v must be either zero or otherwise >= 1 sec", kc.ShutdownGracePeriod))
		}

	"k8s.io/client-go/informers"
	"k8s.io/client-go/kubernetes/fake"
	"k8s.io/client-go/tools/cache"
)

func TestBeforeSynced(t *testing.T) {
	kc := fake.NewSimpleClientset()

	informerFactory := informers.NewSharedInformerFactoryWithOptions(kc, 0)

	ctbInformer := informerFactory.Certificates().V1alpha1().ClusterTrustBundles()
	ctbManager, _ := NewInformerManager(ctbInformer, 256, 5*time.Minute)

			var objs []runtime.Object
			if tc.existingConfigMap != nil {
				objs = []runtime.Object{tc.existingConfigMap}
			}
			kc := kube.NewFakeClient(objs...)
			fake := kc.Kube().(*fake.Clientset)
			configmaps := kclient.New[*v1.ConfigMap](kc)
			if tc.clientMod != nil {
				tc.clientMod(fake)
			}
			kc.RunAndWait(test.NewStop(t))
			fake.ClearActions()
			err := InsertDataToConfigMap(configmaps, tc.meta, tc.caBundle)

	})
	return gatewayError
}

func TestGreenfield(t *testing.T) {
	controllerStop := make(chan struct{})
	clientStop := test.NewStop(t)
	kc := kube.NewFakeClient()
	gatewayError := setupGatewayError(kc)
	c := unstartedTestController(kc)
	kc.RunAndWait(clientStop)
	go c.Run(controllerStop)
	webhooks := clienttest.Wrap(t, c.webhooks)
	fetch := func(name string) func() *admission.ValidatingWebhookConfiguration {

	var kc kclient.Untyped
	if s.IsBuiltin() {
		kc = kclient.NewUntypedInformer(cl.client, gvr, filter)
	} else {
		kc = kclient.NewDelayedInformer[controllers.Object](
			cl.client,
			gvr,
			kubetypes.StandardInformer,
			filter,
		)
	}

	kind := s.Kind()
	kc.AddEventHandler(controllers.EventHandler[controllers.Object]{

func NewController(
	kc kube.Client,
	c model.ConfigStoreController,
	waitForCRD func(class schema.GroupVersionResource, stop <-chan struct{}) bool,
	credsController credentials.MulticlusterController,
	options controller.Options,
) *Controller {
	var ctl *status.Controller

	namespaces := kclient.NewFiltered[*corev1.Namespace](kc, kubetypes.Filter{ObjectFilter: kc.ObjectFilter()})
	gatewayController := &Controller{

}

type authorizationKey string

type authorizationResponse struct {
	expiration time.Time
	authorized error
}

var _ credentials.Controller = &CredentialsController{}

func NewCredentialsController(kc kube.Client, handlers []func(name string, namespace string)) *CredentialsController {
	// We only care about TLS certificates and docker config for Wasm image pulling.

	}
}

func createFakeClient(t test.Failer, objects ...runtime.Object) kclient.Client[*corev1.Service] {
	kc := kube.NewFakeClient(objects...)
	stop := test.NewStop(t)
	services := kclient.New[*corev1.Service](kc)
	kc.RunAndWait(stop)
	kube.WaitForCacheSync("test", stop, services.HasSynced)
	return services

	g := withContext(ictx)
	// copy nameflag to avoid race
	nf := nameflag
	g.Go(func(result chan string) error {
		// retrieve latest generation from Kubernetes
		kc, err := cliCtx.CLIClient()
		if err != nil {
			return err
		}
		dclient := kc.Dynamic()
		r := dclient.Resource(targetSchema.GroupVersionResource()).Namespace(cliCtx.Namespace())

	secretNamespace string
	component       *multicluster.Component[*kubeController]
}

// NewMulticluster initializes data structure to store multicluster information
func NewMulticluster(
	serverID string,
	kc kubernetes.Interface,
	secretNamespace string,
	opts Options,
	serviceEntryController *serviceentry.Controller,
	configController model.ConfigStoreController,
	caBundleWatcher *keycertbundle.Watcher,
	revision string,