webhookAuthResolverWrapper := webhook.NewDefaultAuthenticationInfoResolverWrapper(proxyTransport, egressSelector, c.LoopbackClientConfig, tp)
	webhookPluginInitializer := webhookinit.NewPluginInitializer(webhookAuthResolverWrapper, serviceResolver)

	kubePluginInitializer := NewPluginInitializer(
		quotainstall.NewQuotaConfigurationForAdmission(),
		exclusion.Excluded(),
	)

type PluginInitializer struct {
	cloudConfig []byte
}

var _ admission.PluginInitializer = &PluginInitializer{}

// NewPluginInitializer constructs new instance of PluginInitializer
func NewPluginInitializer(cloudConfig []byte) *PluginInitializer {
	return &PluginInitializer{
		cloudConfig: cloudConfig,
	}
}

	quotaConfiguration         quota.Configuration
	excludedAdmissionResources []schema.GroupResource
}

var _ admission.PluginInitializer = &PluginInitializer{}

// NewPluginInitializer constructs new instance of PluginInitializer
func NewPluginInitializer(
	quotaConfiguration quota.Configuration,
	excludedAdmissionResources []schema.GroupResource,
) *PluginInitializer {
	return &PluginInitializer{

	authenticationInfoResolverWrapper webhook.AuthenticationInfoResolverWrapper
}

var _ admission.PluginInitializer = &PluginInitializer{}

// NewPluginInitializer constructs new instance of PluginInitializer
func NewPluginInitializer(
	authenticationInfoResolverWrapper webhook.AuthenticationInfoResolverWrapper,
	serviceResolver webhook.ServiceResolver,
) *PluginInitializer {
	return &PluginInitializer{

		cloudConfig, err = os.ReadFile(c.CloudConfigFile)
		if err != nil {
			klog.Fatalf("Error reading from cloud configuration file %s: %#v", c.CloudConfigFile, err)
		}
	}

	return []admission.PluginInitializer{NewPluginInitializer(cloudConfig)}, nil

	p.cloudConfig = cloudConfig
}

func TestCloudConfigAdmissionPlugin(t *testing.T) {
	cloudConfig := []byte("cloud-configuration")
	initializer := NewPluginInitializer(cloudConfig)
	wantsCloudConfigAdmission := &WantsCloudConfigAdmissionPlugin{}
	initializer.Initialize(wantsCloudConfigAdmission)

	if wantsCloudConfigAdmission.cloudConfig == nil {

}

func (s *serviceWanter) SetServiceResolver(sr webhook.ServiceResolver) { s.got = sr }

func TestWantsServiceResolver(t *testing.T) {
	sw := &serviceWanter{}
	fsr := &fakeServiceResolver{}
	i := NewPluginInitializer(nil, fsr)
	i.Initialize(sw)
	if got, ok := sw.got.(*fakeServiceResolver); !ok || got != fsr {
		t.Errorf("plumbing fail - %v %v#", ok, got)
	}

	p.config = config
}

func TestQuotaConfigurationAdmissionPlugin(t *testing.T) {
	config := doNothingQuotaConfiguration{}
	initializer := NewPluginInitializer(config, nil)
	wantsQuotaConfigurationAdmission := &WantsQuotaConfigurationAdmissionPlugin{}
	initializer.Initialize(wantsQuotaConfigurationAdmission)

	if wantsQuotaConfigurationAdmission.config == nil {

	}
	restMapper := restmapper.NewDiscoveryRESTMapper(restMapperRes)
	genericPluginInitializer := initializer.New(nil, nil, nil, fakeAuthorizer{}, nil, nil, restMapper)
	pluginInitializer := controlplaneadmission.NewPluginInitializer(nil, nil)
	initializersChain := apiserveradmission.PluginInitializers{}
	initializersChain = append(initializersChain, genericPluginInitializer)
	initializersChain = append(initializersChain, pluginInitializer)

	if err != nil {
		return nil, err
	}

	initializers := admission.PluginInitializers{
		genericadmissioninitializer.New(kubeClient, nil, informerFactory, nil, nil, stopCh, nil),
		controlplaneadmission.NewPluginInitializer(quotaConfiguration, nil),
	}
	initializers.Initialize(handler)

	return handler, admission.ValidateInitialization(handler)
}