}

func TestParseWatchCacheSizes(t *testing.T) {
	testCases := []struct {
		name                  string
		cacheSizes            []string
		expectWatchCacheSizes map[schema.GroupResource]int
		expectErr             string
	}{
		{
			name:       "test when invalid value of watch cache size",
			cacheSizes: []string{"deployments.apps#65536", "replicasets.extensions"},
			expectErr:  "invalid value of watch cache size",
		},

	var cacheSizes []string

	for resource, size := range watchCacheSizes {
		if size < 0 {
			return nil, fmt.Errorf("watch cache size cannot be negative for resource %s", resource)
		}
		cacheSizes = append(cacheSizes, fmt.Sprintf("%s#%d", resource.String(), size))
	}
	return cacheSizes, nil
}

var _ serverstorage.StorageFactory = &SimpleStorageFactory{}

						Timeout:    &metav1.Duration{Duration: 3 * time.Second},
						CacheSize:  &cacheSize,
						APIVersion: "v1",
					},
				}, {
					KMS: &apiserver.KMSConfiguration{
						Name:       "foo",
						Endpoint:   "unix:///tmp/kms-provider-2.socket",
						Timeout:    &metav1.Duration{Duration: 3 * time.Second},
						CacheSize:  &cacheSize,
						APIVersion: "v1",
					},
				}},
			}},
		},

			want: &KMSConfiguration{Timeout: defaultTimeout, CacheSize: &defaultCacheSize, APIVersion: defaultAPIVersion},
		},
		{
			desc: "cache of zero size supplied",
			in:   &KMSConfiguration{CacheSize: &zero},
			want: &KMSConfiguration{Timeout: defaultTimeout, CacheSize: &zero, APIVersion: defaultAPIVersion},
		},
		{
			desc: "positive cache size supplied",
			in:   &KMSConfiguration{CacheSize: &ten},

			limitType: config.Type,
			cache: &singleCache{
				rateLimiter: rateLimiterFactory(),
			},
			keyFunc: getServerKey,
		}, nil
	}

	cacheSize := int(config.CacheSize)
	if cacheSize == 0 {
		cacheSize = defaultCacheSize
	}
	underlyingCache := lru.New(cacheSize)
	cache := &lruCache{
		rateLimiterFactory: rateLimiterFactory,
		cache:              underlyingCache,
	}

	var keyFunc func(admission.Attributes) string

				Type:      "Namespace",
				Burst:     10,
				QPS:       2,
				CacheSize: 100,
			}},
		},
		expectedResult: true,
	}, {
		name: "valid user",
		config: eventratelimitapi.Configuration{
			Limits: []eventratelimitapi.Limit{{
				Type:      "User",
				Burst:     10,
				QPS:       2,
				CacheSize: 100,
			}},
		},
		expectedResult: true,
	}, {
		name: "valid source+object",

	// allowance of burst queries.
	//
	// The default cache size is 4096.
	//
	// If limitType is 'server', then cacheSize is ignored.
	// +optional
	CacheSize int32 `json:"cacheSize,omitempty"`

	if obj.Timeout == nil {
		obj.Timeout = defaultTimeout
	}

	if obj.APIVersion == "" {
		obj.APIVersion = defaultAPIVersion
	}

	// cacheSize is relevant only for kms v1
	if obj.CacheSize == nil && obj.APIVersion == "v1" {
		obj.CacheSize = &defaultCacheSize
	}

	var (
		cache *lru.Cache
	)

	if cacheSize > 0 {
		cache = lru.New(cacheSize)
	}
	return &envelopeTransformer{
		envelopeService:     envelopeService,
		transformers:        cache,
		baseTransformerFunc: baseTransformerFunc,
		cacheEnabled:        cacheSize > 0,
		cacheSize:           cacheSize,
	}
}

apiVersion: apiserver.config.k8s.io/v1
resources:
  - resources:
      - secrets
    providers:
      - kms:
          name: kms-provider-1
          cachesize: 1000
          endpoint: unix:///@provider1.sock
      - kms:
          name: kms-provider-2
          cachesize: 1000