def "invalidates cache when verification file changes"() {
        server.start()
        def v3 = remoteRepo.module("thing", "lib", "1.3").publish()
        def checkSum = getChecksum(v3, "sha256")
        v3.allowAll()

        taskTypeLogsInputFileCollectionContent()
        buildFile << """
            configurations {
                implementation
            }

    }

    static libRequest(MavenHttpRepository repo, String group, String name, Object version) {
        MavenHttpModule module = repo.module(group, name, version as String)
        module.allowAll()
    }

    def withSharedResources() {
        resources.maybeCopy('MavenConversionIntegrationTest/sharedResources')
    }

    static PomHttpArtifact expectParentPomRequest(MavenHttpRepository repo) {

        javaLibrary()
        def foo = uncheckedModule("org", "foo", "1.0") {
            dependsOn("org", "bar", "1.0")
        }
        def bar = ivyHttpRepo.module("org", "bar", "1.0")
            .allowAll()
            .publish()
        buildFile << """
            repositories {
                ivy { url "${ivyHttpRepo.uri}" }
            }

            dependencies {

			}
			if tt.wantErr {
				if err == nil {
					t.Errorf("expected error making authorization request: %v", err)
				}
				return
			}
			if err != nil {
				t.Errorf("%s: failed to authorize with AllowAll policy: %v", tt.test, err)
				return
			}

			service.Deny()
			if decision, _, _ := wh.Authorize(context.Background(), attr); decision == authorizer.DecisionAllow {

                }
            }
        """
    }

    def withExternalLibDependency(artifactId = "lib1") {
        def lib = mavenHttpRepo.module('org.test.foo', artifactId).publish()
        lib.allowAll()
        """
            project(':lib') {
                dependencies {
                    compile 'org.test.foo:${artifactId}:${lib.version}'
                }
            }
        """
    }

						AllowedNames: sets.New[string](),
					}
				}
				if to.Name != nil {
					res[fromKey][toKey].AllowedNames.Insert(string(*to.Name))
				} else {
					res[fromKey][toKey].AllowAll = true
				}
			}
		}
	}
	return res
}

// convertVirtualService takes all xRoute types and generates corresponding VirtualServices.
func convertVirtualService(r configContext) []config.Config {

* Add support for running clusters on GCI ([#24893](https://github.com/kubernetes/kubernetes/pull/24893), [@andyzheng0831](https://github.com/andyzheng0831))
* Switch to ABAC authorization from AllowAll ([#24210](https://github.com/kubernetes/kubernetes/pull/24210), [@cjcullen](https://github.com/cjcullen))

		{
			test: "config within normal ranges",
			config: imagePolicyWebhookConfig{
				AllowTTL:     ((minAllowTTL + maxAllowTTL) / 2) / time.Second,
				DenyTTL:      ((minDenyTTL + maxDenyTTL) / 2) / time.Second,
				RetryBackoff: ((minRetryBackoff + maxRetryBackoff) / 2) / time.Millisecond,
			},
			normalizedConfig: imagePolicyWebhookConfig{
				AllowTTL:     ((minAllowTTL + maxAllowTTL) / 2) / time.Second * time.Second,

)

// imagePolicyWebhookConfig holds config data for imagePolicyWebhook
type imagePolicyWebhookConfig struct {
	KubeConfigFile string        `json:"kubeConfigFile"`
	AllowTTL       time.Duration `json:"allowTTL"`
	DenyTTL        time.Duration `json:"denyTTL"`
	RetryBackoff   time.Duration `json:"retryBackoff"`
	DefaultAllow   bool          `json:"defaultAllow"`
}

	webhook       *webhook.GenericWebhook
	responseCache *cache.LRUExpireCache
	allowTTL      time.Duration
	denyTTL       time.Duration
	defaultAllow  bool
}

var _ admission.ValidationInterface = &Plugin{}

func (a *Plugin) statusTTL(status v1alpha1.ImageReviewStatus) time.Duration {
	if status.Allowed {
		return a.allowTTL
	}
	return a.denyTTL
}