diff --git a/Makefile b/Makefile index 55580b4715..fac467bfd9 100644 --- a/Makefile +++ b/Makefile @@ -259,21 +259,14 @@ E2E_TIMEOUT ?= 10m e2e: #EXHELP Run the e2e tests. go test -count=1 -v ./test/e2e/features_test.go -timeout=$(E2E_TIMEOUT) -E2E_REGISTRY_NAME := docker-registry -E2E_REGISTRY_NAMESPACE := operator-controller-e2e - -export REG_PKG_NAME := registry-operator -export CLUSTER_REGISTRY_HOST := $(E2E_REGISTRY_NAME).$(E2E_REGISTRY_NAMESPACE).svc:5000 -export LOCAL_REGISTRY_HOST := localhost:30000 -export E2E_TEST_CATALOG_V1 := e2e/test-catalog:v1 -export E2E_TEST_CATALOG_V2 := e2e/test-catalog:v2 -export CATALOG_IMG := $(CLUSTER_REGISTRY_HOST)/$(E2E_TEST_CATALOG_V1) +export CLUSTER_REGISTRY_HOST := docker-registry.operator-controller-e2e.svc:5000 .PHONY: extension-developer-e2e -extension-developer-e2e: $(OPERATOR_SDK) $(KUSTOMIZE) #EXHELP Run extension create, upgrade and delete tests. - test/extension-developer-e2e/setup.sh $(OPERATOR_SDK) $(CONTAINER_RUNTIME) $(KUSTOMIZE) ${LOCAL_REGISTRY_HOST} ${CLUSTER_REGISTRY_HOST} +extension-developer-e2e: export OPERATOR_SDK := $(OPERATOR_SDK) +extension-developer-e2e: export CONTAINER_RUNTIME := $(CONTAINER_RUNTIME) +extension-developer-e2e: $(OPERATOR_SDK) #EXHELP Run extension create, upgrade and delete tests. go test -count=1 -v ./test/extension-developer-e2e/... -UNIT_TEST_DIRS := $(shell go list ./... | grep -vE "/test/|/testutils") +UNIT_TEST_DIRS := $(shell go list ./... | grep -vE "/test/|/testutils") $(shell go list ./test/internal/...) COVERAGE_UNIT_DIR := $(ROOT_DIR)/coverage/unit .PHONY: envtest-k8s-bins #HELP Uses setup-envtest to download and install the binaries required to run ENVTEST-test based locally at the project/bin directory. @@ -298,15 +291,6 @@ test-regression: #HELP Run regression test rm -rf $(COVERAGE_REGRESSION_DIR) && mkdir -p $(COVERAGE_REGRESSION_DIR) go test -count=1 -v ./test/regression/... -cover -coverprofile ${ROOT_DIR}/coverage/regression.out -test.gocoverdir=$(COVERAGE_REGRESSION_DIR) -.PHONY: image-registry -E2E_REGISTRY_IMAGE=localhost/e2e-test-registry:devel -image-registry: export GOOS=linux -image-registry: export GOARCH=amd64 -image-registry: ## Build the testdata catalog used for e2e tests and push it to the image registry - go build $(GO_BUILD_FLAGS) $(GO_BUILD_EXTRA_FLAGS) -tags '$(GO_BUILD_TAGS)' -ldflags '$(GO_BUILD_LDFLAGS)' -gcflags '$(GO_BUILD_GCFLAGS)' -asmflags '$(GO_BUILD_ASMFLAGS)' -o ./testdata/push/bin/push ./testdata/push/push.go - $(CONTAINER_RUNTIME) build -f ./testdata/Dockerfile -t $(E2E_REGISTRY_IMAGE) ./testdata - $(KIND) load docker-image $(E2E_REGISTRY_IMAGE) --name $(KIND_CLUSTER_NAME) - ./testdata/build-test-registry.sh $(E2E_REGISTRY_NAMESPACE) $(E2E_REGISTRY_NAME) $(E2E_REGISTRY_IMAGE) # When running the e2e suite, you can set the ARTIFACT_PATH variable to the absolute path # of the directory for the operator-controller e2e tests to store the artifacts, which @@ -320,7 +304,7 @@ test-e2e: GO_BUILD_EXTRA_FLAGS := -cover test-e2e: COVERAGE_NAME := e2e test-e2e: export MANIFEST := $(STANDARD_RELEASE_MANIFEST) test-e2e: export INSTALL_DEFAULT_CATALOGS := false -test-e2e: run-internal image-registry prometheus e2e e2e-coverage kind-clean #HELP Run e2e test suite on local kind cluster +test-e2e: run-internal prometheus e2e e2e-coverage kind-clean #HELP Run e2e test suite on local kind cluster .PHONY: test-experimental-e2e test-experimental-e2e: SOURCE_MANIFEST := $(EXPERIMENTAL_E2E_MANIFEST) @@ -331,8 +315,8 @@ test-experimental-e2e: COVERAGE_NAME := experimental-e2e test-experimental-e2e: export MANIFEST := $(EXPERIMENTAL_RELEASE_MANIFEST) test-experimental-e2e: export INSTALL_DEFAULT_CATALOGS := false test-experimental-e2e: PROMETHEUS_VALUES := helm/prom_experimental.yaml -test-experimental-e2e: E2E_TIMEOUT := 15m -test-experimental-e2e: run-internal image-registry prometheus e2e e2e-coverage kind-clean #HELP Run experimental e2e test suite on local kind cluster +test-experimental-e2e: E2E_TIMEOUT := 20m +test-experimental-e2e: run-internal prometheus e2e e2e-coverage kind-clean #HELP Run experimental e2e test suite on local kind cluster .PHONY: prometheus prometheus: PROMETHEUS_NAMESPACE := olmv1-system @@ -349,7 +333,7 @@ test-extension-developer-e2e: SOURCE_MANIFEST := $(STANDARD_E2E_MANIFEST) test-extension-developer-e2e: KIND_CLUSTER_NAME := operator-controller-ext-dev-e2e test-extension-developer-e2e: export INSTALL_DEFAULT_CATALOGS := false test-extension-developer-e2e: export MANIFEST := $(STANDARD_RELEASE_MANIFEST) -test-extension-developer-e2e: run-internal image-registry extension-developer-e2e kind-clean #HELP Run extension-developer e2e on local kind cluster +test-extension-developer-e2e: run-internal extension-developer-e2e kind-clean #HELP Run extension-developer e2e on local kind cluster .PHONY: run-latest-release run-latest-release: diff --git a/docs/superpowers/specs/2026-04-13-e2e-test-isolation-design.md b/docs/superpowers/specs/2026-04-13-e2e-test-isolation-design.md new file mode 100644 index 0000000000..b118c6cef2 --- /dev/null +++ b/docs/superpowers/specs/2026-04-13-e2e-test-isolation-design.md @@ -0,0 +1,118 @@ +# E2E Test Isolation: Per-Scenario Catalogs via Dynamic OCI Image Building + +## Problem + +E2E test scenarios previously shared cluster-scoped resources (ClusterCatalogs, CRDs, packages), +causing cascading failures when one scenario left state behind. Parallelism was impossible because +scenarios conflicted on shared resource names. + +## Solution + +Each scenario dynamically builds and pushes its own bundle and catalog OCI images at test time, +parameterized by scenario ID. All cluster-scoped resource names include the scenario ID, making +conflicts structurally impossible. + +``` +Scenario starts + -> Generate parameterized bundle manifests (CRD names, deployments, etc. include scenario ID) + -> Build + push bundle OCI images to e2e registry via go-containerregistry + -> Generate FBC catalog config referencing those bundle image refs + -> Build + push catalog OCI image to e2e registry + -> Create ClusterCatalog pointing at the catalog image + -> Run scenario steps + -> Cleanup all resources (including catalog) +``` + +### Key Properties + +- Every cluster-scoped resource name includes the scenario ID -- no conflicts by construction. +- Failed scenario state is preserved for debugging without affecting other scenarios. +- Parallelism (`Concurrency > 1`) is safe without further changes. +- Adding new scenarios requires zero coordination with existing ones. + +## Builder API (`test/e2e/catalog/`) + +Bundles are defined as components of a catalog. A single `Build()` call builds and pushes +all bundle images, generates the FBC, and pushes the catalog image: + +```go +cat := catalog.NewCatalog("test", scenarioID, + catalog.WithPackage("test", + catalog.Bundle("1.0.0", catalog.WithCRD(), catalog.WithDeployment(), catalog.WithConfigMap()), + catalog.Bundle("1.2.0", catalog.WithCRD(), catalog.WithDeployment()), + catalog.Channel("beta", catalog.Entry("1.0.0"), catalog.Entry("1.2.0")), + ), +) +result, err := cat.Build(ctx, "v1", localRegistry, clusterRegistry) +// result.CatalogName = "test-catalog-{scenarioID}" +// result.CatalogImageRef = "{clusterRegistry}/e2e/test-catalog-{scenarioID}:v1" +// result.PackageNames = {"test": "test-{scenarioID}"} +``` + +### Bundle Options + +- `WithCRD()` -- CRD with group `e2e-{id}.e2e.operatorframework.io` +- `WithDeployment()` -- Deployment named `test-operator-{id}` (includes CSV, script ConfigMap, NetworkPolicy) +- `WithConfigMap()` -- additional test ConfigMap +- `WithInstallMode(modes...)` -- sets supported install modes on the CSV +- `WithLargeCRD(fieldCount)` -- CRD with many fields for large bundle testing +- `WithClusterRegistry(host)` -- overrides the cluster-side registry host (for mirror testing) +- `StaticBundleDir(dir)` -- reads pre-built bundle manifests without parameterization (e.g. webhook-operator) +- `BadImage()` -- uses an invalid container image to trigger ImagePullBackOff +- `WithBundleProperty(type, value)` -- adds a property to bundle metadata + +## Feature File Conventions + +Feature files define catalogs inline via data tables: + +```gherkin +Background: + Given OLM is available + And an image registry is available + And a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.0.0 | alpha | | CRD, Deployment, ConfigMap | + | test | 1.0.1 | alpha | 1.0.0 | CRD, Deployment, ConfigMap | + | test | 1.2.0 | beta | | CRD, Deployment | +``` + +### Variable Substitution + +Templates in feature file YAML use these variables: + +| Variable | Expansion | Example | +|----------|-----------|---------| +| `${NAME}` | ClusterExtension name | `ce-abc123` | +| `${TEST_NAMESPACE}` | Scenario namespace | `ns-abc123` | +| `${SCENARIO_ID}` | Unique scenario identifier | `abc123` | +| `${PACKAGE:}` | Parameterized package name | `test-abc123` | +| `${CATALOG:}` | ClusterCatalog resource name | `test-catalog-abc123` | +| `${COS_NAME}` | ClusterObjectSet name | `cos-abc123` | + +### Naming Conventions + +| Resource | Pattern | +|----------|---------| +| CRD group | `e2e-{id}.e2e.operatorframework.io` | +| Deployment | `test-operator-{id}` | +| Package name (FBC) | `{package}-{id}` | +| Bundle image | `{registry}/bundles/{package}-{id}:v{version}` | +| Catalog image | `{registry}/e2e/{name}-catalog-{id}:{tag}` | +| ClusterCatalog | `{name}-catalog-{id}` | +| Namespace | `ns-{id}` | +| ClusterExtension | `ce-{id}` | + +## Registry Access + +An in-cluster OCI registry (`test/internal/registry/`) stores bundle and catalog images. +The registry runs as a ClusterIP Service; there is no NodePort or kind `extraPortMappings`. + +The test runner reaches the registry via **Kubernetes port-forward** (SPDY through the API +server), which works regardless of the cluster's network topology. A `sync.OnceValues` in the +step definitions starts the port-forward once and returns the dynamically assigned +`localhost:` address used for all `crane.Push` / `crane.Tag` calls. + +In-cluster components (e.g. the catalog unpacker) pull images using the Service DNS name +(`docker-registry.operator-controller-e2e.svc.cluster.local:5000`), resolved by CoreDNS. +Containerd on the node is never involved because the registry only holds OCI artifacts +consumed by Go code, not container images for pods. diff --git a/go.mod b/go.mod index 7c8c266fcd..7059238372 100644 --- a/go.mod +++ b/go.mod @@ -90,6 +90,7 @@ require ( github.com/containerd/typeurl/v2 v2.2.3 // indirect github.com/containers/libtrust v0.0.0-20230121012942-c1716e8a8d01 // indirect github.com/containers/ocicrypt v1.2.1 // indirect + github.com/creack/pty v1.1.24 // indirect github.com/cucumber/gherkin/go/v26 v26.2.0 // indirect github.com/cucumber/messages/go/v21 v21.0.1 // indirect github.com/cyberphone/json-canonicalization v0.0.0-20241213102144-19d51d7fe467 // indirect @@ -141,6 +142,7 @@ require ( github.com/google/gnostic-models v0.7.1 // indirect github.com/google/uuid v1.6.0 // indirect github.com/gorilla/mux v1.8.1 // indirect + github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674 // indirect github.com/gosuri/uitable v0.0.4 // indirect github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79 // indirect github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.7 // indirect @@ -172,6 +174,7 @@ require ( github.com/mitchellh/go-wordwrap v1.0.1 // indirect github.com/mitchellh/reflectwalk v1.0.2 // indirect github.com/moby/locker v1.0.1 // indirect + github.com/moby/spdystream v0.5.0 // indirect github.com/moby/sys/capability v0.4.0 // indirect github.com/moby/sys/mountinfo v0.7.2 // indirect github.com/moby/sys/sequential v0.6.0 // indirect @@ -182,6 +185,7 @@ require ( github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee // indirect github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect + github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f // indirect github.com/nxadm/tail v1.4.11 // indirect github.com/onsi/gomega v1.39.1 // indirect github.com/opencontainers/runtime-spec v1.3.0 // indirect diff --git a/go.sum b/go.sum index 6b28e34901..25561d0411 100644 --- a/go.sum +++ b/go.sum @@ -34,6 +34,8 @@ github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d h1:licZJFw2RwpH github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d/go.mod h1:asat636LX7Bqt5lYEZ27JNDcqxfjdBQuJ/MM4CN/Lzo= github.com/antlr4-go/antlr/v4 v4.13.1 h1:SqQKkuVZ+zWkMMNkjy5FZe5mr5WURWnlpmOuzYWrPrQ= github.com/antlr4-go/antlr/v4 v4.13.1/go.mod h1:GKmUxMtwp6ZgGwZSva4eWPC5mS6vUAmOABFgjdkM7Nw= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so= github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= @@ -87,8 +89,8 @@ github.com/coreos/go-systemd/v22 v22.6.0 h1:aGVa/v8B7hpb0TKl0MWoAavPDmHvobFe5R5z github.com/coreos/go-systemd/v22 v22.6.0/go.mod h1:iG+pp635Fo7ZmV/j14KUcmEyWF+0X7Lua8rrTWzYgWU= github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g= -github.com/creack/pty v1.1.18 h1:n56/Zwd5o6whRC5PMGretI4IdRLlmBXYNjScPaBgsbY= -github.com/creack/pty v1.1.18/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4= +github.com/creack/pty v1.1.24 h1:bJrF4RRfyJnbTJqzRLHzcGaZK1NeM5kTC9jGgovnR1s= +github.com/creack/pty v1.1.24/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE= github.com/cucumber/gherkin/go/v26 v26.2.0 h1:EgIjePLWiPeslwIWmNQ3XHcypPsWAHoMCz/YEBKP4GI= github.com/cucumber/gherkin/go/v26 v26.2.0/go.mod h1:t2GAPnB8maCT4lkHL99BDCVNzCh1d7dBhCLt150Nr/0= github.com/cucumber/godog v0.15.1 h1:rb/6oHDdvVZKS66hrhpjFQFHjthFSrQBCOI1LwshNTI= @@ -274,6 +276,8 @@ github.com/gorilla/handlers v1.5.2 h1:cLTUSsNkgcwhgRqvCNmdbRWG0A3N4F+M2nWKdScwyE github.com/gorilla/handlers v1.5.2/go.mod h1:dX+xVpaxdSw+q0Qek8SSsl3dfMk3jNddUkMzo0GtH0w= github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= +github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674 h1:JeSE6pjso5THxAzdVpqr6/geYxZytqFMBCOtn/ujyeo= +github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674/go.mod h1:r4w70xmWCQKmi1ONH4KIaBptdivuRPyosB9RmPlGEwA= github.com/gosuri/uitable v0.0.4 h1:IG2xLKRvErL3uhY6e1BylFzG+aJiwQviDDTfOKeKTpY= github.com/gosuri/uitable v0.0.4/go.mod h1:tKR86bXuXPZazfOTG1FIzvjIdXzd0mo4Vtn16vt0PJo= github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79 h1:+ngKgrYPPJrOjhax5N+uePQ0Fh1Z7PheYoUI/0nzkPA= @@ -369,6 +373,8 @@ github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zx github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw= github.com/moby/locker v1.0.1 h1:fOXqR41zeveg4fFODix+1Ch4mj/gT0NE1XJbp/epuBg= github.com/moby/locker v1.0.1/go.mod h1:S7SDdo5zpBK84bzzVlKr2V0hz+7x9hWbYC/kq7oQppc= +github.com/moby/spdystream v0.5.0 h1:7r0J1Si3QO/kjRitvSLVVFUjxMEb/YLj6S9FF62JBCU= +github.com/moby/spdystream v0.5.0/go.mod h1:xBAYlnt/ay+11ShkdFKNAG7LsyK/tmNBVvVOwrfMgdI= github.com/moby/sys/capability v0.4.0 h1:4D4mI6KlNtWMCM1Z/K0i7RV1FkX+DBDHKVJpCndZoHk= github.com/moby/sys/capability v0.4.0/go.mod h1:4g9IK291rVkms3LKCDOoYlnV8xKwoDTpIrNEE35Wq0I= github.com/moby/sys/mountinfo v0.7.2 h1:1shs6aH5s4o5H2zQLn796ADW1wMrIwHsyJ2v9KouLrg= @@ -393,6 +399,8 @@ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f h1:KUppIJq7/+SVif2QVs3tOP0zanoHgBEVAwHxUSIzRqU= github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= +github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f h1:y5//uYreIhSUg3J1GEMiLbxo1LJaP8RfCpH6pymGZus= +github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+o7JKHSa8/e818NopupXU1YMK5fe1lsApnBw= github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY= github.com/nxadm/tail v1.4.11/go.mod h1:OTaG3NK980DZzxbRq6lEuzgU+mug70nY11sMd4JXXHc= github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= diff --git a/hack/kind-config/containerd/certs.d/docker-registry.operator-controller-e2e.svc.cluster.local:5000/hosts.toml b/hack/kind-config/containerd/certs.d/docker-registry.operator-controller-e2e.svc.cluster.local:5000/hosts.toml deleted file mode 100644 index b0a5eb47fc..0000000000 --- a/hack/kind-config/containerd/certs.d/docker-registry.operator-controller-e2e.svc.cluster.local:5000/hosts.toml +++ /dev/null @@ -1,3 +0,0 @@ -[host."https://localhost:30000"] - capabilities = ["pull", "resolve"] - skip_verify = true diff --git a/hack/kind-config/containerd/certs.d/go.mod b/hack/kind-config/containerd/certs.d/go.mod deleted file mode 100644 index 2cf82571b4..0000000000 --- a/hack/kind-config/containerd/certs.d/go.mod +++ /dev/null @@ -1,5 +0,0 @@ -module hack-cert.d -// This file is present in the certs.d directory to ensure that -// certs.d/host:port directories are not included in the main go -// module. Go modules are not allowed to contain files with ':' -// in their name. diff --git a/internal/operator-controller/applier/boxcutter_test.go b/internal/operator-controller/applier/boxcutter_test.go index b1360cb47e..31cfc81557 100644 --- a/internal/operator-controller/applier/boxcutter_test.go +++ b/internal/operator-controller/applier/boxcutter_test.go @@ -37,14 +37,14 @@ import ( "github.com/operator-framework/operator-controller/internal/operator-controller/applier" "github.com/operator-framework/operator-controller/internal/operator-controller/authorization" "github.com/operator-framework/operator-controller/internal/operator-controller/labels" - "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing/bundlefs" - "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing/clusterserviceversion" + bundlecsv "github.com/operator-framework/operator-controller/internal/testing/bundle/csv" + bundlefs "github.com/operator-framework/operator-controller/internal/testing/bundle/fs" ) var ( dummyBundle = bundlefs.Builder(). WithPackageName("test-package"). - WithCSV(clusterserviceversion.Builder().WithName("test-csv").Build()). + WithCSV(bundlecsv.Builder().WithName("test-csv").Build()). Build() ) @@ -313,7 +313,7 @@ func Test_SimpleRevisionGenerator_GenerateRevision_BundleAnnotations(t *testing. WithPackageName("test-package"). WithBundleProperty("olm.bundle.property", "some-value"). WithBundleProperty("olm.another.bundle.property", "some-other-value"). - WithCSV(clusterserviceversion.Builder().WithName("test-csv").Build()). + WithCSV(bundlecsv.Builder().WithName("test-csv").Build()). Build() rev, err := b.GenerateRevision(t.Context(), bundleFS, ext, map[string]string{}, map[string]string{}) @@ -327,7 +327,7 @@ func Test_SimpleRevisionGenerator_GenerateRevision_BundleAnnotations(t *testing. t.Run("olm.properties should not be present if there are no bundle properties", func(t *testing.T) { bundleFS := bundlefs.Builder(). WithPackageName("test-package"). - WithCSV(clusterserviceversion.Builder().WithName("test-csv").Build()). + WithCSV(bundlecsv.Builder().WithName("test-csv").Build()). Build() rev, err := b.GenerateRevision(t.Context(), bundleFS, ext, map[string]string{}, map[string]string{}) @@ -342,7 +342,7 @@ func Test_SimpleRevisionGenerator_GenerateRevision_BundleAnnotations(t *testing. bundleFS := bundlefs.Builder(). WithPackageName("test-package"). WithBundleProperty("olm.bundle.property", "some-value"). - WithCSV(clusterserviceversion.Builder(). + WithCSV(bundlecsv.Builder(). WithName("test-csv"). WithAnnotations(map[string]string{ "some.csv.annotation": "some-other-value", diff --git a/internal/operator-controller/applier/provider_test.go b/internal/operator-controller/applier/provider_test.go index 5f6913f434..4369fccd26 100644 --- a/internal/operator-controller/applier/provider_test.go +++ b/internal/operator-controller/applier/provider_test.go @@ -22,8 +22,8 @@ import ( "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/render" "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/render/registryv1" . "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing" - "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing/bundlefs" - "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing/clusterserviceversion" + bundlecsv "github.com/operator-framework/operator-controller/internal/testing/bundle/csv" + bundlefs "github.com/operator-framework/operator-controller/internal/testing/bundle/fs" ) func Test_RegistryV1ManifestProvider_Integration(t *testing.T) { @@ -53,7 +53,7 @@ func Test_RegistryV1ManifestProvider_Integration(t *testing.T) { // The contents of the bundle are not important for this tesy, only that it be a valid bundle // to avoid errors in the deserialization process bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()).Build() ext := &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ @@ -83,7 +83,7 @@ func Test_RegistryV1ManifestProvider_Integration(t *testing.T) { // The contents of the bundle are not important for this tesy, only that it be a valid bundle // to avoid errors in the deserialization process bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build()).Build() ext := &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ @@ -116,7 +116,7 @@ func Test_RegistryV1ManifestProvider_Integration(t *testing.T) { // Bundle with SingleNamespace install mode requiring watchNamespace config bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build()).Build() // ClusterExtension without required config ext := &ocv1.ClusterExtension{ @@ -138,7 +138,7 @@ func Test_RegistryV1ManifestProvider_Integration(t *testing.T) { BundleRenderer: registryv1.Renderer, } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()). + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()). WithBundleResource("service.yaml", &corev1.Service{ TypeMeta: metav1.TypeMeta{ APIVersion: corev1.SchemeGroupVersion.String(), @@ -179,7 +179,7 @@ func Test_RegistryV1ManifestProvider_APIServiceSupport(t *testing.T) { provider := applier.RegistryV1ManifestProvider{} bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithOwnedAPIServiceDescriptions(v1alpha1.APIServiceDescription{Name: "test-apiservice"}).Build()).Build() + WithCSV(bundlecsv.Builder().WithOwnedAPIServiceDescriptions(v1alpha1.APIServiceDescription{Name: "test-apiservice"}).Build()).Build() ext := &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ @@ -200,7 +200,7 @@ func Test_RegistryV1ManifestProvider_WebhookSupport(t *testing.T) { } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithWebhookDefinitions(v1alpha1.WebhookDescription{}).Build()).Build() + WithCSV(bundlecsv.Builder().WithWebhookDefinitions(v1alpha1.WebhookDescription{}).Build()).Build() ext := &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ @@ -220,7 +220,7 @@ func Test_RegistryV1ManifestProvider_WebhookSupport(t *testing.T) { } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithWebhookDefinitions(v1alpha1.WebhookDescription{}).Build()).Build() + WithCSV(bundlecsv.Builder().WithWebhookDefinitions(v1alpha1.WebhookDescription{}).Build()).Build() ext := &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ @@ -241,7 +241,7 @@ func Test_RegistryV1ManifestProvider_WebhookSupport(t *testing.T) { bundleFS := bundlefs.Builder().WithPackageName("test"). WithCSV( - clusterserviceversion.Builder(). + bundlecsv.Builder(). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces). WithWebhookDefinitions(v1alpha1.WebhookDescription{}).Build()). Build() @@ -264,7 +264,7 @@ func Test_RegistryV1ManifestProvider_SingleOwnNamespaceSupport(t *testing.T) { } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build()).Build() _, err := provider.Get(bundleFS, &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ @@ -281,7 +281,7 @@ func Test_RegistryV1ManifestProvider_SingleOwnNamespaceSupport(t *testing.T) { } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build()).Build() _, err := provider.Get(bundleFS, &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ @@ -303,7 +303,7 @@ func Test_RegistryV1ManifestProvider_SingleOwnNamespaceSupport(t *testing.T) { IsSingleOwnNamespaceEnabled: false, } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeOwnNamespace).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeOwnNamespace).Build()).Build() _, err := provider.Get(bundleFS, &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ Namespace: "install-namespace", @@ -329,7 +329,7 @@ func Test_RegistryV1ManifestProvider_SingleOwnNamespaceSupport(t *testing.T) { } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build()).Build() _, err := provider.Get(bundleFS, &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ @@ -351,7 +351,7 @@ func Test_RegistryV1ManifestProvider_SingleOwnNamespaceSupport(t *testing.T) { } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build()).Build() _, err := provider.Get(bundleFS, &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ @@ -377,7 +377,7 @@ func Test_RegistryV1ManifestProvider_SingleOwnNamespaceSupport(t *testing.T) { IsSingleOwnNamespaceEnabled: true, } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeOwnNamespace).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeOwnNamespace).Build()).Build() _, err := provider.Get(bundleFS, &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ Namespace: installNamespace, @@ -397,7 +397,7 @@ func Test_RegistryV1ManifestProvider_SingleOwnNamespaceSupport(t *testing.T) { IsSingleOwnNamespaceEnabled: true, } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeOwnNamespace).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeOwnNamespace).Build()).Build() _, err := provider.Get(bundleFS, &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ Namespace: "install-namespace", @@ -412,7 +412,7 @@ func Test_RegistryV1ManifestProvider_SingleOwnNamespaceSupport(t *testing.T) { IsSingleOwnNamespaceEnabled: true, } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeOwnNamespace).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeOwnNamespace).Build()).Build() _, err := provider.Get(bundleFS, &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ Namespace: "install-namespace", @@ -435,7 +435,7 @@ func Test_RegistryV1ManifestProvider_SingleOwnNamespaceSupport(t *testing.T) { IsSingleOwnNamespaceEnabled: true, } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeMultiNamespace).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeMultiNamespace).Build()).Build() _, err := provider.Get(bundleFS, &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ Namespace: "install-namespace", @@ -466,7 +466,7 @@ func Test_RegistryV1ManifestProvider_DeploymentConfig(t *testing.T) { } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()).Build() _, err := provider.Get(bundleFS, &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ @@ -498,7 +498,7 @@ func Test_RegistryV1ManifestProvider_DeploymentConfig(t *testing.T) { } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()).Build() _, err := provider.Get(bundleFS, &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ @@ -531,7 +531,7 @@ func Test_RegistryV1ManifestProvider_DeploymentConfig(t *testing.T) { } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()).Build() _, err := provider.Get(bundleFS, &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ @@ -574,7 +574,7 @@ func Test_RegistryV1ManifestProvider_DeploymentConfig(t *testing.T) { } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build()).Build() _, err := provider.Get(bundleFS, &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ @@ -611,7 +611,7 @@ func Test_RegistryV1ManifestProvider_DeploymentConfig(t *testing.T) { } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()).Build() _, err := provider.Get(bundleFS, &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ @@ -641,7 +641,7 @@ func Test_RegistryV1ManifestProvider_DeploymentConfig(t *testing.T) { } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()).Build() // Provide deploymentConfig with invalid structure - env should be array, not string // Schema validation catches this before conversion @@ -676,7 +676,7 @@ func Test_RegistryV1ManifestProvider_DeploymentConfig(t *testing.T) { } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()).Build() _, err := provider.Get(bundleFS, &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ @@ -708,7 +708,7 @@ func Test_RegistryV1ManifestProvider_DeploymentConfig(t *testing.T) { } bundleFS := bundlefs.Builder().WithPackageName("test"). - WithCSV(clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()).Build() + WithCSV(bundlecsv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build()).Build() _, err := provider.Get(bundleFS, &ocv1.ClusterExtension{ Spec: ocv1.ClusterExtensionSpec{ @@ -771,7 +771,7 @@ func Test_RegistryV1HelmChartProvider_Chart(t *testing.T) { bundleFS := bundlefs.Builder().WithPackageName("test"). WithCSV( - clusterserviceversion.Builder(). + bundlecsv.Builder(). WithAnnotations(map[string]string{"foo": "bar"}). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces). Build()). diff --git a/internal/operator-controller/config/config_test.go b/internal/operator-controller/config/config_test.go index e7429eeba9..2f38ad6d35 100644 --- a/internal/operator-controller/config/config_test.go +++ b/internal/operator-controller/config/config_test.go @@ -13,7 +13,7 @@ import ( "github.com/operator-framework/operator-controller/internal/operator-controller/config" "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/bundle" - "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing/clusterserviceversion" + "github.com/operator-framework/operator-controller/internal/testing/bundle/csv" ) func Test_UnmarshalConfig(t *testing.T) { @@ -296,7 +296,7 @@ func Test_UnmarshalConfig(t *testing.T) { var rv1 bundle.RegistryV1 if tc.supportedInstallModes != nil { rv1 = bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithName("test-operator"). WithInstallModeSupportFor(tc.supportedInstallModes...). Build(), diff --git a/internal/operator-controller/config/error_formatting_test.go b/internal/operator-controller/config/error_formatting_test.go index 6ec1ebf7de..4013d70f29 100644 --- a/internal/operator-controller/config/error_formatting_test.go +++ b/internal/operator-controller/config/error_formatting_test.go @@ -10,7 +10,7 @@ import ( "github.com/operator-framework/operator-controller/internal/operator-controller/config" "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/bundle" - "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing/clusterserviceversion" + "github.com/operator-framework/operator-controller/internal/testing/bundle/csv" ) // Test_ErrorFormatting_SchemaLibraryVersion verifies error messages from the JSON schema @@ -122,7 +122,7 @@ func Test_ErrorFormatting_SchemaLibraryVersion(t *testing.T) { } { t.Run(tc.name, func(t *testing.T) { rv1 := bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithName("test-operator"). WithInstallModeSupportFor(tc.supportedInstallModes...). Build(), @@ -177,7 +177,7 @@ func Test_ErrorFormatting_YAMLParseErrors(t *testing.T) { } { t.Run(tc.name, func(t *testing.T) { rv1 := bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithName("test-operator"). WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace). Build(), diff --git a/internal/operator-controller/rukpak/bundle/source/source_test.go b/internal/operator-controller/rukpak/bundle/source/source_test.go index 45ccafd0dc..1a2ab4698f 100644 --- a/internal/operator-controller/rukpak/bundle/source/source_test.go +++ b/internal/operator-controller/rukpak/bundle/source/source_test.go @@ -13,8 +13,8 @@ import ( "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/bundle" "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/bundle/source" - "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing/bundlefs" - "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing/clusterserviceversion" + "github.com/operator-framework/operator-controller/internal/testing/bundle/csv" + bundlefs "github.com/operator-framework/operator-controller/internal/testing/bundle/fs" ) const ( @@ -34,7 +34,7 @@ func Test_FromFS_Success(t *testing.T) { bundleFS := bundlefs.Builder(). WithPackageName("test"). WithBundleProperty("from-file-key", "from-file-value"). - WithBundleResource("csv.yaml", ptr.To(clusterserviceversion.Builder(). + WithBundleResource("csv.yaml", ptr.To(csv.Builder(). WithName("test.v1.0.0"). WithAnnotations(map[string]string{ "olm.properties": `[{"type":"from-csv-annotations-key", "value":"from-csv-annotations-value"}]`, @@ -72,12 +72,12 @@ func Test_FromFS_Fails(t *testing.T) { name: "bundle missing metadata/annotations.yaml", FS: bundlefs.Builder(). WithBundleProperty("foo", "bar"). - WithBundleResource("csv.yaml", ptr.To(clusterserviceversion.Builder().Build())).Build(), + WithBundleResource("csv.yaml", ptr.To(csv.Builder().Build())).Build(), }, { name: "metadata/annotations.yaml missing package name annotation", FS: bundlefs.Builder(). WithBundleProperty("foo", "bar"). - WithBundleResource("csv.yaml", ptr.To(clusterserviceversion.Builder().Build())).Build(), + WithBundleResource("csv.yaml", ptr.To(csv.Builder().Build())).Build(), }, { name: "bundle missing manifests directory", FS: bundlefs.Builder(). diff --git a/internal/operator-controller/rukpak/render/registryv1/generators/generators_test.go b/internal/operator-controller/rukpak/render/registryv1/generators/generators_test.go index 31897ada8d..3caf006c39 100644 --- a/internal/operator-controller/rukpak/render/registryv1/generators/generators_test.go +++ b/internal/operator-controller/rukpak/render/registryv1/generators/generators_test.go @@ -26,7 +26,7 @@ import ( "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/render" "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/render/registryv1/generators" . "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing" - "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing/clusterserviceversion" + "github.com/operator-framework/operator-controller/internal/testing/bundle/csv" ) func Test_ResourceGenerators(t *testing.T) { @@ -70,7 +70,7 @@ func Test_BundleCSVDeploymentGenerator_Succeeds(t *testing.T) { { name: "generates deployment resources", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithAnnotations(map[string]string{ "csv": "annotation", }). @@ -176,7 +176,7 @@ func Test_BundleCSVDeploymentGenerator_WithCertWithCertProvider_Succeeds(t *test } b := &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.ValidatingAdmissionWebhook, @@ -371,7 +371,7 @@ func Test_BundleCSVPermissionsGenerator_Succeeds(t *testing.T) { UniqueNameGenerator: fakeUniqueNameGenerator, }, bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithName("csv"). WithPermissions( v1alpha1.StrategyDeploymentPermissions{ @@ -396,7 +396,7 @@ func Test_BundleCSVPermissionsGenerator_Succeeds(t *testing.T) { UniqueNameGenerator: fakeUniqueNameGenerator, }, bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithName("csv"). WithPermissions( v1alpha1.StrategyDeploymentPermissions{ @@ -470,7 +470,7 @@ func Test_BundleCSVPermissionsGenerator_Succeeds(t *testing.T) { UniqueNameGenerator: fakeUniqueNameGenerator, }, bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithName("csv"). WithPermissions( v1alpha1.StrategyDeploymentPermissions{ @@ -588,7 +588,7 @@ func Test_BundleCSVPermissionsGenerator_Succeeds(t *testing.T) { UniqueNameGenerator: fakeUniqueNameGenerator, }, bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithName("csv"). WithPermissions( v1alpha1.StrategyDeploymentPermissions{ @@ -704,7 +704,7 @@ func Test_BundleCSVPermissionsGenerator_Succeeds(t *testing.T) { UniqueNameGenerator: fakeUniqueNameGenerator, }, bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithName("csv"). WithPermissions( v1alpha1.StrategyDeploymentPermissions{ @@ -800,7 +800,7 @@ func Test_BundleCSVClusterPermissionsGenerator_Succeeds(t *testing.T) { UniqueNameGenerator: fakeUniqueNameGenerator, }, bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithName("csv"). WithPermissions( v1alpha1.StrategyDeploymentPermissions{ @@ -920,7 +920,7 @@ func Test_BundleCSVClusterPermissionsGenerator_Succeeds(t *testing.T) { UniqueNameGenerator: fakeUniqueNameGenerator, }, bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithName("csv"). WithClusterPermissions( v1alpha1.StrategyDeploymentPermissions{ @@ -1032,7 +1032,7 @@ func Test_BundleCSVClusterPermissionsGenerator_Succeeds(t *testing.T) { UniqueNameGenerator: fakeUniqueNameGenerator, }, bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithName("csv"). WithClusterPermissions( v1alpha1.StrategyDeploymentPermissions{ @@ -1120,7 +1120,7 @@ func Test_BundleCSVServiceAccountGenerator_Succeeds(t *testing.T) { InstallNamespace: "install-namespace", }, bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithName("csv"). WithPermissions( v1alpha1.StrategyDeploymentPermissions{ @@ -1206,7 +1206,7 @@ func Test_BundleCSVServiceAccountGenerator_Succeeds(t *testing.T) { InstallNamespace: "install-namespace", }, bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithName("csv"). WithPermissions( v1alpha1.StrategyDeploymentPermissions{ @@ -1289,7 +1289,7 @@ func Test_BundleCRDGenerator_WithConversionWebhook_Succeeds(t *testing.T) { {ObjectMeta: metav1.ObjectMeta{Name: "crd-one"}}, {ObjectMeta: metav1.ObjectMeta{Name: "crd-two"}}, }, - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.ConversionWebhook, @@ -1373,7 +1373,7 @@ func Test_BundleCRDGenerator_WithConversionWebhook_Fails(t *testing.T) { }, }, }, - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.ConversionWebhook, @@ -1413,7 +1413,7 @@ func Test_BundleCRDGenerator_WithCertProvider_Succeeds(t *testing.T) { {ObjectMeta: metav1.ObjectMeta{Name: "crd-one"}}, {ObjectMeta: metav1.ObjectMeta{Name: "crd-two"}}, }, - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.ConversionWebhook, @@ -1502,7 +1502,7 @@ func Test_BundleValidatingWebhookResourceGenerator_Succeeds(t *testing.T) { { name: "generates validating webhook configuration resources described in the bundle's cluster service version", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.ValidatingAdmissionWebhook, @@ -1595,7 +1595,7 @@ func Test_BundleValidatingWebhookResourceGenerator_Succeeds(t *testing.T) { { name: "removes any - suffixes from the webhook name (v0 used GenerateName to allow multiple operator installations - we don't want that in v1)", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.ValidatingAdmissionWebhook, @@ -1696,7 +1696,7 @@ func Test_BundleValidatingWebhookResourceGenerator_Succeeds(t *testing.T) { { name: "generates validating webhook configuration resources with certificate provider modifications", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.ValidatingAdmissionWebhook, @@ -1782,7 +1782,7 @@ func Test_BundleMutatingWebhookResourceGenerator_Succeeds(t *testing.T) { { name: "generates validating webhook configuration resources described in the bundle's cluster service version", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.MutatingAdmissionWebhook, @@ -1877,7 +1877,7 @@ func Test_BundleMutatingWebhookResourceGenerator_Succeeds(t *testing.T) { { name: "removes any - suffixes from the webhook name (v0 used GenerateName to allow multiple operator installations - we don't want that in v1)", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.MutatingAdmissionWebhook, @@ -1980,7 +1980,7 @@ func Test_BundleMutatingWebhookResourceGenerator_Succeeds(t *testing.T) { { name: "generates validating webhook configuration resources with certificate provider modifications", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.MutatingAdmissionWebhook, @@ -2066,7 +2066,7 @@ func Test_BundleDeploymentServiceResourceGenerator_Succeeds(t *testing.T) { { name: "generates webhook services using container port 443 and target port 443 by default", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "my-deployment", @@ -2110,7 +2110,7 @@ func Test_BundleDeploymentServiceResourceGenerator_Succeeds(t *testing.T) { { name: "generates webhook services using the given container port and setting target port the same as the container port if not given", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "my-deployment", @@ -2155,7 +2155,7 @@ func Test_BundleDeploymentServiceResourceGenerator_Succeeds(t *testing.T) { { name: "generates webhook services using given container port of 443 and given target port", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "my-deployment", @@ -2203,7 +2203,7 @@ func Test_BundleDeploymentServiceResourceGenerator_Succeeds(t *testing.T) { { name: "generates webhook services using given container port and target port", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "my-deployment", @@ -2252,7 +2252,7 @@ func Test_BundleDeploymentServiceResourceGenerator_Succeeds(t *testing.T) { { name: "generates webhook services using referenced deployment defined label selector", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "my-deployment", @@ -2311,7 +2311,7 @@ func Test_BundleDeploymentServiceResourceGenerator_Succeeds(t *testing.T) { { name: "aggregates all webhook definitions referencing the same deployment into a single service", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "my-deployment", @@ -2408,7 +2408,7 @@ func Test_BundleDeploymentServiceResourceGenerator_Succeeds(t *testing.T) { { name: "applies cert provider modifiers to webhook service", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "my-deployment", @@ -2482,7 +2482,7 @@ func Test_CertProviderResourceGenerator_Succeeds(t *testing.T) { } objs, err := generators.CertProviderResourceGenerator(&bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( // only generate resources for deployments referenced by webhook definitions v1alpha1.WebhookDescription{ @@ -2521,7 +2521,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "applies env vars from deployment config", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -2587,7 +2587,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "applies resources from deployment config", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -2633,7 +2633,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "applies tolerations from deployment config", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -2678,7 +2678,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "applies node selector from deployment config", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -2717,7 +2717,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "applies affinity from deployment config", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -2769,7 +2769,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "empty affinity erases bundle affinity", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -2853,7 +2853,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "empty nodeAffinity erases only nodeAffinity", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -2922,7 +2922,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "empty nodeAffinity with empty nodeSelectorTerms erases only nodeAffinity", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -2996,7 +2996,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "nil affinity preserves bundle affinity", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -3045,7 +3045,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "partial affinity override preserves unspecified fields", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -3133,7 +3133,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "empty sub-fields erase to nil affinity", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -3202,7 +3202,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "empty nodeAffinity without bundle affinity stays nil", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -3237,7 +3237,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "empty affinity without bundle affinity stays nil", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -3270,7 +3270,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "applies annotations from deployment config", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithAnnotations(map[string]string{ "csv-annotation": "csv-value", }). @@ -3326,7 +3326,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "applies volumes and volume mounts from deployment config", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -3381,7 +3381,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "applies envFrom from deployment config", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -3434,7 +3434,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "applies all config fields together", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -3498,7 +3498,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "applies config to multiple containers", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -3550,7 +3550,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "nil deployment config does nothing", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -3589,7 +3589,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "merges volumes from deployment config - overrides matching names", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", @@ -3696,7 +3696,7 @@ func Test_BundleCSVDeploymentGenerator_WithDeploymentConfig(t *testing.T) { { name: "merges volumeMounts from deployment config - overrides matching names", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "test-deployment", diff --git a/internal/operator-controller/rukpak/render/registryv1/registryv1_test.go b/internal/operator-controller/rukpak/render/registryv1/registryv1_test.go index 009d47c136..f84a2305ed 100644 --- a/internal/operator-controller/rukpak/render/registryv1/registryv1_test.go +++ b/internal/operator-controller/rukpak/render/registryv1/registryv1_test.go @@ -17,7 +17,7 @@ import ( "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/render/registryv1/generators" "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/render/registryv1/validators" . "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing" - "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing/clusterserviceversion" + "github.com/operator-framework/operator-controller/internal/testing/bundle/csv" ) func Test_BundleValidatorHasAllValidationFns(t *testing.T) { @@ -68,7 +68,7 @@ func Test_ResourceGeneratorsHasAllGenerators(t *testing.T) { func Test_Renderer_Success(t *testing.T) { someBundle := bundle.RegistryV1{ PackageName: "my-package", - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithName("test-bundle"). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), Others: []unstructured.Unstructured{ @@ -101,7 +101,7 @@ func Test_Renderer_Success(t *testing.T) { func Test_Renderer_Failure_UnsupportedKind(t *testing.T) { someBundle := bundle.RegistryV1{ PackageName: "my-package", - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithName("test-bundle"). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), Others: []unstructured.Unstructured{ diff --git a/internal/operator-controller/rukpak/render/registryv1/validators/validator_test.go b/internal/operator-controller/rukpak/render/registryv1/validators/validator_test.go index cf0e0728e2..1ba329fc08 100644 --- a/internal/operator-controller/rukpak/render/registryv1/validators/validator_test.go +++ b/internal/operator-controller/rukpak/render/registryv1/validators/validator_test.go @@ -15,7 +15,7 @@ import ( "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/bundle" "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/render/registryv1/validators" - "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing/clusterserviceversion" + "github.com/operator-framework/operator-controller/internal/testing/bundle/csv" ) func Test_CheckDeploymentSpecUniqueness(t *testing.T) { @@ -27,7 +27,7 @@ func Test_CheckDeploymentSpecUniqueness(t *testing.T) { { name: "accepts bundles with unique deployment strategy spec names", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{Name: "test-deployment-one"}, v1alpha1.StrategyDeploymentSpec{Name: "test-deployment-two"}, @@ -37,7 +37,7 @@ func Test_CheckDeploymentSpecUniqueness(t *testing.T) { }, { name: "rejects bundles with duplicate deployment strategy spec names", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{Name: "test-deployment-one"}, v1alpha1.StrategyDeploymentSpec{Name: "test-deployment-two"}, @@ -50,7 +50,7 @@ func Test_CheckDeploymentSpecUniqueness(t *testing.T) { }, { name: "errors are ordered by deployment strategy spec name", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{Name: "test-deployment-a"}, v1alpha1.StrategyDeploymentSpec{Name: "test-deployment-b"}, @@ -81,7 +81,7 @@ func Test_CheckDeploymentNameIsDNS1123SubDomain(t *testing.T) { { name: "accepts valid deployment strategy spec names", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{Name: "test-deployment-one"}, v1alpha1.StrategyDeploymentSpec{Name: "test-deployment-two"}, @@ -91,7 +91,7 @@ func Test_CheckDeploymentNameIsDNS1123SubDomain(t *testing.T) { }, { name: "rejects bundles with invalid deployment strategy spec names - errors are sorted by name", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{Name: "-bad-name"}, v1alpha1.StrategyDeploymentSpec{Name: "b-name-is-waaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaay-too-long"}, @@ -170,7 +170,7 @@ func Test_CheckOwnedCRDExistence(t *testing.T) { {ObjectMeta: metav1.ObjectMeta{Name: "a.crd.something"}}, {ObjectMeta: metav1.ObjectMeta{Name: "b.crd.something"}}, }, - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithOwnedCRDs( v1alpha1.CRDDescription{Name: "a.crd.something"}, v1alpha1.CRDDescription{Name: "b.crd.something"}, @@ -181,7 +181,7 @@ func Test_CheckOwnedCRDExistence(t *testing.T) { name: "rejects bundles with missing owned custom resource definition resources", bundle: &bundle.RegistryV1{ CRDs: []apiextensionsv1.CustomResourceDefinition{}, - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithOwnedCRDs(v1alpha1.CRDDescription{Name: "a.crd.something"}).Build(), }, expectedErrs: []error{ @@ -191,7 +191,7 @@ func Test_CheckOwnedCRDExistence(t *testing.T) { name: "errors are ordered by owned custom resource definition name", bundle: &bundle.RegistryV1{ CRDs: []apiextensionsv1.CustomResourceDefinition{}, - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithOwnedCRDs( v1alpha1.CRDDescription{Name: "a.crd.something"}, v1alpha1.CRDDescription{Name: "c.crd.something"}, @@ -247,7 +247,7 @@ func Test_CheckWebhookSupport(t *testing.T) { { name: "accepts bundles with conversion webhook definitions when they only support AllNamespaces install mode", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces). WithWebhookDefinitions( v1alpha1.WebhookDescription{ @@ -259,7 +259,7 @@ func Test_CheckWebhookSupport(t *testing.T) { { name: "accepts bundles with validating webhook definitions when they support more modes than AllNamespaces install mode", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces, v1alpha1.InstallModeTypeSingleNamespace). WithWebhookDefinitions( v1alpha1.WebhookDescription{ @@ -271,7 +271,7 @@ func Test_CheckWebhookSupport(t *testing.T) { { name: "accepts bundles with mutating webhook definitions when they support more modes than AllNamespaces install mode", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces, v1alpha1.InstallModeTypeSingleNamespace). WithWebhookDefinitions( v1alpha1.WebhookDescription{ @@ -283,7 +283,7 @@ func Test_CheckWebhookSupport(t *testing.T) { { name: "rejects bundles with conversion webhook definitions when they support more modes than AllNamespaces install mode", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace, v1alpha1.InstallModeTypeAllNamespaces). WithWebhookDefinitions( v1alpha1.WebhookDescription{ @@ -318,7 +318,7 @@ func Test_CheckWebhookRules(t *testing.T) { { name: "accepts bundles with webhook definitions without rules", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces). WithWebhookDefinitions( v1alpha1.WebhookDescription{ @@ -333,7 +333,7 @@ func Test_CheckWebhookRules(t *testing.T) { { name: "accepts bundles with webhook definitions with supported rules", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces). WithWebhookDefinitions( v1alpha1.WebhookDescription{ @@ -364,7 +364,7 @@ func Test_CheckWebhookRules(t *testing.T) { { name: "reject bundles with webhook definitions with rules containing '*' api group", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces). WithWebhookDefinitions( v1alpha1.WebhookDescription{ @@ -399,7 +399,7 @@ func Test_CheckWebhookRules(t *testing.T) { { name: "reject bundles with webhook definitions with rules containing 'olm.operatorframework.io' api group", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces). WithWebhookDefinitions( v1alpha1.WebhookDescription{ @@ -434,7 +434,7 @@ func Test_CheckWebhookRules(t *testing.T) { { name: "reject bundles with webhook definitions with rules containing 'admissionregistration.k8s.io' api group and '*' resource", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces). WithWebhookDefinitions( v1alpha1.WebhookDescription{ @@ -458,7 +458,7 @@ func Test_CheckWebhookRules(t *testing.T) { { name: "reject bundles with webhook definitions with rules containing 'admissionregistration.k8s.io' api group and 'MutatingWebhookConfiguration' resource", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces). WithWebhookDefinitions( v1alpha1.WebhookDescription{ @@ -482,7 +482,7 @@ func Test_CheckWebhookRules(t *testing.T) { { name: "reject bundles with webhook definitions with rules containing 'admissionregistration.k8s.io' api group and 'mutatingwebhookconfiguration' resource", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces). WithWebhookDefinitions( v1alpha1.WebhookDescription{ @@ -506,7 +506,7 @@ func Test_CheckWebhookRules(t *testing.T) { { name: "reject bundles with webhook definitions with rules containing 'admissionregistration.k8s.io' api group and 'mutatingwebhookconfigurations' resource", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces). WithWebhookDefinitions( v1alpha1.WebhookDescription{ @@ -530,7 +530,7 @@ func Test_CheckWebhookRules(t *testing.T) { { name: "reject bundles with webhook definitions with rules containing 'admissionregistration.k8s.io' api group and 'ValidatingWebhookConfiguration' resource", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces). WithWebhookDefinitions( v1alpha1.WebhookDescription{ @@ -554,7 +554,7 @@ func Test_CheckWebhookRules(t *testing.T) { { name: "reject bundles with webhook definitions with rules containing 'admissionregistration.k8s.io' api group and 'validatingwebhookconfiguration' resource", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces). WithWebhookDefinitions( v1alpha1.WebhookDescription{ @@ -578,7 +578,7 @@ func Test_CheckWebhookRules(t *testing.T) { { name: "reject bundles with webhook definitions with rules containing 'admissionregistration.k8s.io' api group and 'validatingwebhookconfigurations' resource", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces). WithWebhookDefinitions( v1alpha1.WebhookDescription{ @@ -616,7 +616,7 @@ func Test_CheckWebhookDeploymentReferentialIntegrity(t *testing.T) { { name: "accepts bundles where webhook definitions reference existing strategy deployment specs", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{Name: "test-deployment-one"}, v1alpha1.StrategyDeploymentSpec{Name: "test-deployment-two"}, @@ -632,7 +632,7 @@ func Test_CheckWebhookDeploymentReferentialIntegrity(t *testing.T) { }, { name: "rejects bundles with webhook definitions that reference non-existing strategy deployment specs", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{Name: "test-deployment-one"}, ). @@ -650,7 +650,7 @@ func Test_CheckWebhookDeploymentReferentialIntegrity(t *testing.T) { }, { name: "errors are ordered by deployment strategy spec name, webhook type, and webhook name", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{Name: "test-deployment-one"}, ). @@ -711,12 +711,12 @@ func Test_CheckWebhookNameUniqueness(t *testing.T) { { name: "accepts bundles without webhook definitions", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder().Build(), + CSV: csv.Builder().Build(), }, }, { name: "accepts bundles with unique webhook names", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.MutatingAdmissionWebhook, @@ -742,7 +742,7 @@ func Test_CheckWebhookNameUniqueness(t *testing.T) { }, { name: "accepts bundles with webhooks with the same name but different types", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.MutatingAdmissionWebhook, @@ -759,7 +759,7 @@ func Test_CheckWebhookNameUniqueness(t *testing.T) { }, { name: "rejects bundles with duplicate validating webhook definitions", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.ValidatingAdmissionWebhook, @@ -776,7 +776,7 @@ func Test_CheckWebhookNameUniqueness(t *testing.T) { }, { name: "rejects bundles with duplicate mutating webhook definitions", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.MutatingAdmissionWebhook, @@ -793,7 +793,7 @@ func Test_CheckWebhookNameUniqueness(t *testing.T) { }, { name: "rejects bundles with duplicate conversion webhook definitions", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.ConversionWebhook, @@ -810,7 +810,7 @@ func Test_CheckWebhookNameUniqueness(t *testing.T) { }, { name: "orders errors by webhook type and name", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.ValidatingAdmissionWebhook, @@ -884,7 +884,7 @@ func Test_CheckConversionWebhooksReferenceOwnedCRDs(t *testing.T) { }, { name: "accepts bundles without conversion webhook definitions", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.ValidatingAdmissionWebhook, @@ -899,7 +899,7 @@ func Test_CheckConversionWebhooksReferenceOwnedCRDs(t *testing.T) { }, { name: "accepts bundles with conversion webhooks that reference owned CRDs", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithOwnedCRDs( v1alpha1.CRDDescription{Name: "some.crd.something"}, v1alpha1.CRDDescription{Name: "another.crd.something"}, @@ -918,7 +918,7 @@ func Test_CheckConversionWebhooksReferenceOwnedCRDs(t *testing.T) { }, { name: "rejects bundles with conversion webhooks that reference existing CRDs that are not owned", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithOwnedCRDs( v1alpha1.CRDDescription{Name: "some.crd.something"}, ). @@ -939,7 +939,7 @@ func Test_CheckConversionWebhooksReferenceOwnedCRDs(t *testing.T) { }, { name: "errors are ordered by webhook name and CRD name", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithOwnedCRDs( v1alpha1.CRDDescription{Name: "b.crd.something"}, ). @@ -996,7 +996,7 @@ func Test_CheckConversionWebhookCRDReferenceUniqueness(t *testing.T) { { name: "accepts bundles without conversion webhook definitions", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.ValidatingAdmissionWebhook, @@ -1013,7 +1013,7 @@ func Test_CheckConversionWebhookCRDReferenceUniqueness(t *testing.T) { { name: "accepts bundles with conversion webhooks that reference different CRDs", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithOwnedCRDs( v1alpha1.CRDDescription{Name: "some.crd.something"}, v1alpha1.CRDDescription{Name: "another.crd.something"}, @@ -1040,7 +1040,7 @@ func Test_CheckConversionWebhookCRDReferenceUniqueness(t *testing.T) { { name: "rejects bundles with conversion webhooks that reference the same CRD", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithOwnedCRDs( v1alpha1.CRDDescription{Name: "some.crd.something"}, ). @@ -1068,7 +1068,7 @@ func Test_CheckConversionWebhookCRDReferenceUniqueness(t *testing.T) { { name: "errors are ordered by CRD name and webhook names", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithOwnedCRDs( v1alpha1.CRDDescription{Name: "b.crd.something"}, ). @@ -1121,12 +1121,12 @@ func Test_CheckWebhookNameIsDNS1123SubDomain(t *testing.T) { { name: "accepts bundles without webhook definitions", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder().Build(), + CSV: csv.Builder().Build(), }, }, { name: "rejects bundles with invalid webhook definitions names and orders errors by webhook type and name", bundle: &bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithWebhookDefinitions( v1alpha1.WebhookDescription{ Type: v1alpha1.ValidatingAdmissionWebhook, diff --git a/internal/operator-controller/rukpak/render/render_test.go b/internal/operator-controller/rukpak/render/render_test.go index 452f9f3fdb..4af451f317 100644 --- a/internal/operator-controller/rukpak/render/render_test.go +++ b/internal/operator-controller/rukpak/render/render_test.go @@ -17,14 +17,14 @@ import ( "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/bundle" "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/render" . "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing" - "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing/clusterserviceversion" + "github.com/operator-framework/operator-controller/internal/testing/bundle/csv" ) func Test_BundleRenderer_NoConfig(t *testing.T) { renderer := render.BundleRenderer{} objs, err := renderer.Render( bundle.RegistryV1{ - CSV: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), + CSV: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), }, "", nil) require.NoError(t, err) require.Empty(t, objs) @@ -156,7 +156,7 @@ func Test_BundleRenderer_DefaultTargetNamespaces(t *testing.T) { }, } _, err := renderer.Render(bundle.RegistryV1{ - CSV: clusterserviceversion.Builder(). + CSV: csv.Builder(). WithName("test"). WithInstallModeSupportFor(tc.supportedInstallModes...).Build(), }, "some-namespace") @@ -181,14 +181,14 @@ func Test_BundleRenderer_ValidatesRenderOptions(t *testing.T) { { name: "accepts empty targetNamespaces (because it is ignored)", installNamespace: "install-namespace", - csv: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), + csv: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), opts: []render.Option{ render.WithTargetNamespaces(), }, }, { name: "rejects nil unique name generator", installNamespace: "install-namespace", - csv: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), + csv: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), opts: []render.Option{ render.WithUniqueNameGenerator(nil), }, @@ -196,7 +196,7 @@ func Test_BundleRenderer_ValidatesRenderOptions(t *testing.T) { }, { name: "rejects all namespace install if AllNamespaces install mode is not supported", installNamespace: "install-namespace", - csv: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build(), + csv: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build(), opts: []render.Option{ render.WithTargetNamespaces(corev1.NamespaceAll), }, @@ -204,7 +204,7 @@ func Test_BundleRenderer_ValidatesRenderOptions(t *testing.T) { }, { name: "rejects own namespace install if only AllNamespace install mode is supported", installNamespace: "install-namespace", - csv: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), + csv: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), opts: []render.Option{ render.WithTargetNamespaces("install-namespace"), }, @@ -212,7 +212,7 @@ func Test_BundleRenderer_ValidatesRenderOptions(t *testing.T) { }, { name: "rejects install out of own namespace if only OwnNamespace install mode is supported", installNamespace: "install-namespace", - csv: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeOwnNamespace).Build(), + csv: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeOwnNamespace).Build(), opts: []render.Option{ render.WithTargetNamespaces("not-install-namespace"), }, @@ -220,7 +220,7 @@ func Test_BundleRenderer_ValidatesRenderOptions(t *testing.T) { }, { name: "rejects multi-namespace install if MultiNamespace install mode is not supported", installNamespace: "install-namespace", - csv: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), + csv: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), opts: []render.Option{ render.WithTargetNamespaces("ns1", "ns2", "ns3"), }, @@ -228,7 +228,7 @@ func Test_BundleRenderer_ValidatesRenderOptions(t *testing.T) { }, { name: "rejects if bundle supports no install modes", installNamespace: "install-namespace", - csv: clusterserviceversion.Builder().Build(), + csv: csv.Builder().Build(), opts: []render.Option{ render.WithTargetNamespaces("some-namespace"), }, @@ -236,42 +236,42 @@ func Test_BundleRenderer_ValidatesRenderOptions(t *testing.T) { }, { name: "accepts all namespace render if AllNamespaces install mode is supported", installNamespace: "install-namespace", - csv: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), + csv: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), opts: []render.Option{ render.WithTargetNamespaces(""), }, }, { name: "accepts install namespace render if SingleNamespace install mode is supported", installNamespace: "install-namespace", - csv: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build(), + csv: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build(), opts: []render.Option{ render.WithTargetNamespaces("some-namespace"), }, }, { name: "accepts all install namespace render if OwnNamespace install mode is supported", installNamespace: "install-namespace", - csv: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeOwnNamespace).Build(), + csv: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeOwnNamespace).Build(), opts: []render.Option{ render.WithTargetNamespaces("install-namespace"), }, }, { name: "accepts single namespace render if SingleNamespace install mode is supported", installNamespace: "install-namespace", - csv: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build(), + csv: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeSingleNamespace).Build(), opts: []render.Option{ render.WithTargetNamespaces("some-namespace"), }, }, { name: "accepts multi namespace render if MultiNamespace install mode is supported", installNamespace: "install-namespace", - csv: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeMultiNamespace).Build(), + csv: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeMultiNamespace).Build(), opts: []render.Option{ render.WithTargetNamespaces("n1", "n2", "n3"), }, }, { name: "reject multi namespace render if OwnNamespace install mode is not supported and target namespaces include install namespace", installNamespace: "install-namespace", - csv: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeMultiNamespace).Build(), + csv: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeMultiNamespace).Build(), opts: []render.Option{ render.WithTargetNamespaces("n1", "n2", "n3", "install-namespace"), }, @@ -342,7 +342,7 @@ func Test_BundleRenderer_CallsResourceGenerators(t *testing.T) { } objs, err := renderer.Render( bundle.RegistryV1{ - CSV: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), + CSV: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), }, "") require.NoError(t, err) require.Equal(t, []client.Object{&corev1.Namespace{}, &corev1.Service{}, &appsv1.Deployment{}}, objs) @@ -361,7 +361,7 @@ func Test_BundleRenderer_ReturnsResourceGeneratorErrors(t *testing.T) { } objs, err := renderer.Render( bundle.RegistryV1{ - CSV: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), + CSV: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), }, "") require.Nil(t, objs) require.Error(t, err) @@ -404,7 +404,7 @@ func Test_WithDeploymentConfig(t *testing.T) { _, err := renderer.Render( bundle.RegistryV1{ - CSV: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), + CSV: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), }, "test-namespace", render.WithDeploymentConfig(expectedConfig), @@ -427,7 +427,7 @@ func Test_WithDeploymentConfig(t *testing.T) { _, err := renderer.Render( bundle.RegistryV1{ - CSV: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), + CSV: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), }, "test-namespace", ) @@ -449,7 +449,7 @@ func Test_WithDeploymentConfig(t *testing.T) { _, err := renderer.Render( bundle.RegistryV1{ - CSV: clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), + CSV: csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces).Build(), }, "test-namespace", render.WithDeploymentConfig(nil), diff --git a/internal/operator-controller/rukpak/util/testing/clusterserviceversion/builder.go b/internal/testing/bundle/csv/builder.go similarity index 99% rename from internal/operator-controller/rukpak/util/testing/clusterserviceversion/builder.go rename to internal/testing/bundle/csv/builder.go index e7ae2195d9..8933f1aa5a 100644 --- a/internal/operator-controller/rukpak/util/testing/clusterserviceversion/builder.go +++ b/internal/testing/bundle/csv/builder.go @@ -1,4 +1,4 @@ -package clusterserviceversion +package csv import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" diff --git a/internal/operator-controller/rukpak/util/testing/clusterserviceversion/builder_test.go b/internal/testing/bundle/csv/builder_test.go similarity index 88% rename from internal/operator-controller/rukpak/util/testing/clusterserviceversion/builder_test.go rename to internal/testing/bundle/csv/builder_test.go index 45bad4e53c..46f887629c 100644 --- a/internal/operator-controller/rukpak/util/testing/clusterserviceversion/builder_test.go +++ b/internal/testing/bundle/csv/builder_test.go @@ -1,4 +1,4 @@ -package clusterserviceversion_test +package csv_test import ( "testing" @@ -9,12 +9,12 @@ import ( "github.com/operator-framework/api/pkg/operators/v1alpha1" - "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing/clusterserviceversion" + "github.com/operator-framework/operator-controller/internal/testing/bundle/csv" ) func Test_Builder(t *testing.T) { t.Run("builds an empty csv by default", func(t *testing.T) { - obj := clusterserviceversion.Builder().Build() + obj := csv.Builder().Build() require.Equal(t, v1alpha1.ClusterServiceVersion{ TypeMeta: metav1.TypeMeta{ Kind: "ClusterServiceVersion", @@ -24,7 +24,7 @@ func Test_Builder(t *testing.T) { }) t.Run("WithName sets csv .metadata.name", func(t *testing.T) { - obj := clusterserviceversion.Builder().WithName("some-name").Build() + obj := csv.Builder().WithName("some-name").Build() require.Equal(t, v1alpha1.ClusterServiceVersion{ TypeMeta: metav1.TypeMeta{ Kind: "ClusterServiceVersion", @@ -37,7 +37,7 @@ func Test_Builder(t *testing.T) { }) t.Run("WithStrategyDeploymentSpecs sets csv .spec.install.spec.deployments", func(t *testing.T) { - obj := clusterserviceversion.Builder().WithStrategyDeploymentSpecs( + obj := csv.Builder().WithStrategyDeploymentSpecs( v1alpha1.StrategyDeploymentSpec{ Name: "spec-one", }, @@ -69,7 +69,7 @@ func Test_Builder(t *testing.T) { }) t.Run("WithPermissions sets csv .spec.install.spec.permissions", func(t *testing.T) { - obj := clusterserviceversion.Builder().WithPermissions( + obj := csv.Builder().WithPermissions( v1alpha1.StrategyDeploymentPermissions{ ServiceAccountName: "service-account", Rules: []rbacv1.PolicyRule{ @@ -115,7 +115,7 @@ func Test_Builder(t *testing.T) { }) t.Run("WithClusterPermissions sets csv .spec.install.spec.clusterPermissions", func(t *testing.T) { - obj := clusterserviceversion.Builder().WithClusterPermissions( + obj := csv.Builder().WithClusterPermissions( v1alpha1.StrategyDeploymentPermissions{ ServiceAccountName: "service-account", Rules: []rbacv1.PolicyRule{ @@ -161,7 +161,7 @@ func Test_Builder(t *testing.T) { }) t.Run("WithClusterPermissions sets csv .spec.customresourcedefinitions.owned", func(t *testing.T) { - obj := clusterserviceversion.Builder().WithOwnedCRDs( + obj := csv.Builder().WithOwnedCRDs( v1alpha1.CRDDescription{Name: "a.crd.something"}, v1alpha1.CRDDescription{Name: "b.crd.something"}, ).Build() @@ -183,7 +183,7 @@ func Test_Builder(t *testing.T) { }) t.Run("WithInstallModeSupportFor adds all install modes to .spec.installModes and sets supported to true for the given supported install modes", func(t *testing.T) { - obj := clusterserviceversion.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces, v1alpha1.InstallModeTypeSingleNamespace).Build() + obj := csv.Builder().WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces, v1alpha1.InstallModeTypeSingleNamespace).Build() require.Equal(t, v1alpha1.ClusterServiceVersion{ TypeMeta: metav1.TypeMeta{ diff --git a/internal/operator-controller/rukpak/util/testing/bundlefs/bundlefs.go b/internal/testing/bundle/fs/bundlefs.go similarity index 99% rename from internal/operator-controller/rukpak/util/testing/bundlefs/bundlefs.go rename to internal/testing/bundle/fs/bundlefs.go index b9d2d8c25a..9f5b699865 100644 --- a/internal/operator-controller/rukpak/util/testing/bundlefs/bundlefs.go +++ b/internal/testing/bundle/fs/bundlefs.go @@ -1,4 +1,4 @@ -package bundlefs +package fs import ( "fmt" diff --git a/internal/operator-controller/rukpak/util/testing/bundlefs/bundlefs_test.go b/internal/testing/bundle/fs/bundlefs_test.go similarity index 80% rename from internal/operator-controller/rukpak/util/testing/bundlefs/bundlefs_test.go rename to internal/testing/bundle/fs/bundlefs_test.go index 74e8410f35..998df8020f 100644 --- a/internal/operator-controller/rukpak/util/testing/bundlefs/bundlefs_test.go +++ b/internal/testing/bundle/fs/bundlefs_test.go @@ -1,4 +1,4 @@ -package bundlefs_test +package fs_test import ( "testing" @@ -8,18 +8,18 @@ import ( corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing/bundlefs" - "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing/clusterserviceversion" + "github.com/operator-framework/operator-controller/internal/testing/bundle/csv" + "github.com/operator-framework/operator-controller/internal/testing/bundle/fs" ) func Test_BundleFSBuilder(t *testing.T) { t.Run("returns empty bundle file system by default", func(t *testing.T) { - bundleFs := bundlefs.Builder().Build() + bundleFs := fs.Builder().Build() assert.Empty(t, bundleFs) }) t.Run("WithPackageName sets the bundle package annotation", func(t *testing.T) { - bundleFs := bundlefs.Builder().WithPackageName("test").Build() + bundleFs := fs.Builder().WithPackageName("test").Build() require.Contains(t, bundleFs, "metadata/annotations.yaml") require.Equal(t, []byte(`annotations: operators.operatorframework.io.bundle.channel.default.v1: "" @@ -29,7 +29,7 @@ func Test_BundleFSBuilder(t *testing.T) { }) t.Run("WithChannels sets the bundle channels annotation", func(t *testing.T) { - bundleFs := bundlefs.Builder().WithChannels("alpha", "beta", "stable").Build() + bundleFs := fs.Builder().WithChannels("alpha", "beta", "stable").Build() require.Contains(t, bundleFs, "metadata/annotations.yaml") require.Equal(t, []byte(`annotations: operators.operatorframework.io.bundle.channel.default.v1: "" @@ -39,7 +39,7 @@ func Test_BundleFSBuilder(t *testing.T) { }) t.Run("WithDefaultChannel sets the bundle default channel annotation", func(t *testing.T) { - bundleFs := bundlefs.Builder().WithDefaultChannel("stable").Build() + bundleFs := fs.Builder().WithDefaultChannel("stable").Build() require.Contains(t, bundleFs, "metadata/annotations.yaml") require.Equal(t, []byte(`annotations: operators.operatorframework.io.bundle.channel.default.v1: stable @@ -49,7 +49,7 @@ func Test_BundleFSBuilder(t *testing.T) { }) t.Run("WithBundleProperty sets the bundle properties", func(t *testing.T) { - bundleFs := bundlefs.Builder(). + bundleFs := fs.Builder(). WithBundleProperty("foo", "bar"). WithBundleProperty("key", "value"). Build() @@ -64,7 +64,7 @@ func Test_BundleFSBuilder(t *testing.T) { }) t.Run("WithBundleResource adds a resource to the manifests directory", func(t *testing.T) { - bundleFs := bundlefs.Builder().WithBundleResource("service.yaml", &corev1.Service{ + bundleFs := fs.Builder().WithBundleResource("service.yaml", &corev1.Service{ TypeMeta: metav1.TypeMeta{ APIVersion: corev1.SchemeGroupVersion.String(), Kind: "Service", @@ -85,7 +85,7 @@ status: }) t.Run("WithCSV adds a csv to the manifests directory", func(t *testing.T) { - bundleFs := bundlefs.Builder().WithCSV(clusterserviceversion.Builder().WithName("some-csv").Build()).Build() + bundleFs := fs.Builder().WithCSV(csv.Builder().WithName("some-csv").Build()).Build() require.Contains(t, bundleFs, "manifests/csv.yaml") require.Equal(t, []byte(`apiVersion: operators.coreos.com/v1alpha1 kind: ClusterServiceVersion diff --git a/kind-config/kind-config-2node.yaml b/kind-config/kind-config-2node.yaml index 5532a9932c..d87ec06b53 100644 --- a/kind-config/kind-config-2node.yaml +++ b/kind-config/kind-config-2node.yaml @@ -3,11 +3,6 @@ kind: Cluster nodes: - role: control-plane extraPortMappings: - # e2e image registry service's NodePort - - containerPort: 30000 - hostPort: 30000 - listenAddress: "127.0.0.1" - protocol: tcp # prometheus metrics service's NodePort - containerPort: 30900 hostPort: 30900 @@ -25,9 +20,6 @@ nodes: kubeletExtraArgs: node-labels: "ingress-ready=true" taints: [] - extraMounts: - - hostPath: ./hack/kind-config/containerd/certs.d - containerPath: /etc/containerd/certs.d - role: control-plane kubeadmConfigPatches: - | @@ -36,10 +28,3 @@ nodes: kubeletExtraArgs: node-labels: "ingress-ready=true" taints: [] - extraMounts: - - hostPath: ./hack/kind-config/containerd/certs.d - containerPath: /etc/containerd/certs.d -containerdConfigPatches: - - |- - [plugins."io.containerd.grpc.v1.cri".registry] - config_path = "/etc/containerd/certs.d" diff --git a/kind-config/kind-config.yaml b/kind-config/kind-config.yaml index 5b5b3b9139..612940900d 100644 --- a/kind-config/kind-config.yaml +++ b/kind-config/kind-config.yaml @@ -3,11 +3,6 @@ kind: Cluster nodes: - role: control-plane extraPortMappings: - # e2e image registry service's NodePort - - containerPort: 30000 - hostPort: 30000 - listenAddress: "127.0.0.1" - protocol: tcp # prometheus metrics service's NodePort - containerPort: 30900 hostPort: 30900 @@ -19,10 +14,3 @@ nodes: apiServer: extraArgs: enable-admission-plugins: OwnerReferencesPermissionEnforcement - extraMounts: - - hostPath: ./hack/kind-config/containerd/certs.d - containerPath: /etc/containerd/certs.d -containerdConfigPatches: - - |- - [plugins."io.containerd.grpc.v1.cri".registry] - config_path = "/etc/containerd/certs.d" diff --git a/test/e2e/README.md b/test/e2e/README.md index a8bd7ba9b6..fa47f47c7b 100644 --- a/test/e2e/README.md +++ b/test/e2e/README.md @@ -32,15 +32,13 @@ test/e2e/ └── steps/ # Step definitions and test utilities ├── steps.go # Step definition implementations ├── hooks.go # Test hooks and scenario context - └── testdata/ # Test data (RBAC templates, catalogs) + └── testdata/ # Test data (RBAC templates) ├── serviceaccount-template.yaml ├── olm-sa-helm-rbac-template.yaml ├── olm-sa-boxcutter-rbac-template.yaml ├── pvc-probe-sa-boxcutter-rbac-template.yaml ├── cluster-admin-rbac-template.yaml - ├── metrics-reader-rbac-template.yaml - ├── test-catalog-template.yaml - └── extra-catalog-template.yaml + └── metrics-reader-rbac-template.yaml ``` ## Architecture @@ -149,7 +147,7 @@ Manages test lifecycle and scenario-specific context. **Variable Substitution:** -Replaces `${TEST_NAMESPACE}`, `${NAME}`, and `${CATALOG_IMG}` with scenario-specific values. +Replaces `${TEST_NAMESPACE}`, `${NAME}`, `${SCENARIO_ID}`, `${PACKAGE:}`, and `${CATALOG:}` with scenario-specific values. ## Writing Tests @@ -203,7 +201,9 @@ Use these variables in YAML templates: - `${NAME}`: Scenario-specific ClusterExtension name (e.g., `ce-123`) - `${COS_NAME}`: Scenario-specific ClusterObjectSet name (e.g., `cos-123`; for applying ClusterObjectSets directly) - `${TEST_NAMESPACE}`: Scenario-specific namespace (e.g., `ns-123`) -- `${CATALOG_IMG}`: Catalog image reference (defaults to in-cluster registry, overridable via `CATALOG_IMG` env var) +- `${SCENARIO_ID}`: Unique scenario identifier used for resource name isolation +- `${PACKAGE:}`: Parameterized package name (e.g., `${PACKAGE:test}` expands to `test-`) +- `${CATALOG:}`: Catalog resource name (e.g., `${CATALOG:test}` expands to `test-catalog-`) ### 5. Feature Tags @@ -277,8 +277,7 @@ go test test/e2e/features_test.go --log.debug --k8s.cli=oc - `KUBECONFIG`: Path to kubeconfig file (defaults to `~/.kube/config`) - `E2E_SUMMARY_OUTPUT`: Path to write test summary (optional) -- `CATALOG_IMG`: Override default catalog image reference (optional) -- `LOCAL_REGISTRY_HOST`: Local registry host for catalog images +- `CLUSTER_REGISTRY_HOST`: In-cluster registry host for pulling catalog images ## Design Patterns @@ -293,8 +292,8 @@ Each scenario runs in its own namespace with unique resource names, ensuring com The `ScenarioCleanup` hook ensures all resources are deleted after each scenario: -- Kills background processes (e.g., kubectl port-forward) -- Deletes ClusterExtensions +- Deletes ClusterExtensions and ClusterObjectSets +- Deletes ClusterCatalogs - Deletes namespaces - Deletes added resources diff --git a/test/e2e/features/install.feature b/test/e2e/features/install.feature index 96b1cbb92f..ceb5e32c23 100644 --- a/test/e2e/features/install.feature +++ b/test/e2e/features/install.feature @@ -5,10 +5,13 @@ Feature: Install ClusterExtension Background: Given OLM is available - And ClusterCatalog "test" serves bundles - And ServiceAccount "olm-sa" with needed permissions is available in test namespace + And an image registry is available Scenario: Install latest available version + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.2.0 | beta | | CRD, Deployment, ConfigMap | + And ServiceAccount "olm-sa" with needed permissions is available in test namespace When ClusterExtension is applied """ apiVersion: olm.operatorframework.io/v1 @@ -22,20 +25,24 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ Then ClusterExtension is rolled out And ClusterExtension is available - And bundle "test-operator.1.2.0" is installed in version "1.2.0" - And resource "networkpolicy/test-operator-network-policy" is installed - And resource "configmap/test-configmap" is installed - And resource "deployment/test-operator" is installed + And bundle "${PACKAGE:test}.1.2.0" is installed in version "1.2.0" + And resource "networkpolicy/test-operator-${SCENARIO_ID}-network-policy" is installed + And resource "configmap/test-configmap-${SCENARIO_ID}" is installed + And resource "deployment/test-operator-${SCENARIO_ID}" is installed @mirrored-registry - Scenario Outline: Install latest available version from mirrored registry + Scenario: Install latest available version from mirrored registry + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test-mirrored | 1.2.0 | beta | | CRD, Deployment, ConfigMap, ClusterRegistry(mirrored-registry.operator-controller-e2e.svc.cluster.local:5000) | + And ServiceAccount "olm-sa" with needed permissions is available in test namespace When ClusterExtension is applied """ apiVersion: olm.operatorframework.io/v1 @@ -49,26 +56,27 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: + packageName: ${PACKAGE:test-mirrored} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ Then ClusterExtension is rolled out And ClusterExtension is available - And bundle "-operator.1.2.0" is installed in version "1.2.0" - And resource "networkpolicy/test-operator-network-policy" is installed - And resource "configmap/test-configmap" is installed - And resource "deployment/test-operator" is installed - - Examples: - | package-name | - | test-mirrored | - | dynamic | + And bundle "${PACKAGE:test-mirrored}.1.2.0" is installed in version "1.2.0" + And resource "networkpolicy/test-operator-${SCENARIO_ID}-network-policy" is installed + And resource "configmap/test-configmap-${SCENARIO_ID}" is installed + And resource "deployment/test-operator-${SCENARIO_ID}" is installed Scenario: Report that bundle cannot be installed when it exists in multiple catalogs with same priority - Given ClusterCatalog "extra" serves bundles + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.2.0 | beta | | CRD, Deployment, ConfigMap | + And a catalog "extra" with packages: + | package | version | channel | replaces | contents | + | test | 1.2.0 | beta | | CRD, Deployment, ConfigMap | + And ServiceAccount "olm-sa" with needed permissions is available in test namespace When ClusterExtension is applied """ apiVersion: olm.operatorframework.io/v1 @@ -82,14 +90,17 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} """ - Then ClusterExtension reports Progressing as True with Reason Retrying and Message: + Then ClusterExtension reports Progressing as True with Reason Retrying and Message includes: """ - found bundles for package "test" in multiple catalogs with the same priority [extra-catalog test-catalog] + found bundles for package "${PACKAGE:test}" in multiple catalogs with the same priority """ Scenario: Report error when ServiceAccount does not exist + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.2.0 | beta | | CRD, Deployment, ConfigMap | When ClusterExtension is applied """ apiVersion: olm.operatorframework.io/v1 @@ -103,10 +114,10 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ Then ClusterExtension reports Progressing as True with Reason Retrying and Message includes: """ @@ -115,7 +126,10 @@ Feature: Install ClusterExtension @SingleOwnNamespaceInstallSupport Scenario: watchNamespace config is required for extension supporting single namespace - Given ServiceAccount "olm-admin" in test namespace is cluster admin + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | single-namespace-operator | 1.0.0 | alpha | | CRD, Deployment, InstallMode(SingleNamespace) | + And ServiceAccount "olm-admin" in test namespace is cluster admin And resource is applied """ apiVersion: v1 @@ -136,14 +150,13 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: single-namespace-operator + packageName: ${PACKAGE:single-namespace-operator} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ - And ClusterExtension reports Progressing as False with Reason InvalidConfiguration and Message: + And ClusterExtension reports Progressing as False with Reason InvalidConfiguration and Message includes: """ - error for resolved bundle "single-namespace-operator.1.0.0" with version "1.0.0": invalid ClusterExtension configuration: invalid configuration: required field "watchNamespace" is missing """ When ClusterExtension is updated to set config.watchNamespace field @@ -163,18 +176,21 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: single-namespace-operator + packageName: ${PACKAGE:single-namespace-operator} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ Then ClusterExtension reports Installed as True - And bundle "single-namespace-operator.1.0.0" is installed in version "1.0.0" - And operator "single-namespace-operator" target namespace is "single-namespace-operator-target" + And bundle "${PACKAGE:single-namespace-operator}.1.0.0" is installed in version "1.0.0" + And operator "test-operator-${SCENARIO_ID}" target namespace is "single-namespace-operator-target" @SingleOwnNamespaceInstallSupport Scenario: watchNamespace config is required for extension supporting own namespace - Given ServiceAccount "olm-admin" in test namespace is cluster admin + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | own-namespace-operator | 1.0.0 | alpha | | CRD, Deployment, InstallMode(OwnNamespace) | + And ServiceAccount "olm-admin" in test namespace is cluster admin And ClusterExtension is applied without the watchNamespace configuration """ apiVersion: olm.operatorframework.io/v1 @@ -188,16 +204,14 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: own-namespace-operator + packageName: ${PACKAGE:own-namespace-operator} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ - And ClusterExtension reports Progressing as False with Reason InvalidConfiguration and Message: + And ClusterExtension reports Progressing as False with Reason InvalidConfiguration and Message includes: """ - error for resolved bundle "own-namespace-operator.1.0.0" with version - "1.0.0": invalid ClusterExtension configuration: invalid configuration: required - field "watchNamespace" is missing + invalid ClusterExtension configuration: invalid configuration: required field "watchNamespace" is missing """ And ClusterExtension is updated to include the watchNamespace configuration """ @@ -216,18 +230,14 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: own-namespace-operator + packageName: ${PACKAGE:own-namespace-operator} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ - And ClusterExtension reports Progressing as False with Reason InvalidConfiguration and Message: + And ClusterExtension reports Progressing as False with Reason InvalidConfiguration and Message includes: """ - error for resolved bundle "own-namespace-operator.1.0.0" with version - "1.0.0": invalid ClusterExtension configuration: invalid configuration: invalid - format for field "watchNamespace": 'some-ns' is not valid ownNamespaceInstallMode: - invalid value "some-ns": must be "${TEST_NAMESPACE}" (the namespace where the - operator is installed) because this operator only supports OwnNamespace install mode + invalid value "some-ns": must be "${TEST_NAMESPACE}" """ When ClusterExtension is updated to set watchNamespace to own namespace value """ @@ -246,18 +256,21 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: own-namespace-operator + packageName: ${PACKAGE:own-namespace-operator} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ Then ClusterExtension is rolled out And ClusterExtension is available - And operator "own-namespace-operator" target namespace is "${TEST_NAMESPACE}" + And operator "test-operator-${SCENARIO_ID}" target namespace is "${TEST_NAMESPACE}" @WebhookProviderCertManager Scenario: Install operator having webhooks - Given ServiceAccount "olm-admin" in test namespace is cluster admin + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | webhook-operator | 0.0.1 | alpha | | StaticBundleDir(testdata/images/bundles/webhook-operator/v0.0.1) | + And ServiceAccount "olm-admin" in test namespace is cluster admin When ClusterExtension is applied """ apiVersion: olm.operatorframework.io/v1 @@ -271,10 +284,10 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: webhook-operator + packageName: ${PACKAGE:webhook-operator} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ Then ClusterExtension is rolled out And ClusterExtension is available @@ -324,7 +337,10 @@ Feature: Install ClusterExtension @SingleOwnNamespaceInstallSupport Scenario: Report failure when watchNamespace has invalid DNS-1123 name - Given ServiceAccount "olm-admin" in test namespace is cluster admin + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | single-namespace-operator | 1.0.0 | alpha | | CRD, Deployment, InstallMode(SingleNamespace) | + And ServiceAccount "olm-admin" in test namespace is cluster admin When ClusterExtension is applied """ apiVersion: olm.operatorframework.io/v1 @@ -342,10 +358,10 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: single-namespace-operator + packageName: ${PACKAGE:single-namespace-operator} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ Then ClusterExtension reports Progressing as False with Reason InvalidConfiguration and Message includes: """ @@ -355,7 +371,10 @@ Feature: Install ClusterExtension @SingleOwnNamespaceInstallSupport @WebhookProviderCertManager Scenario: Reject watchNamespace for operator that does not support Single/OwnNamespace install modes - Given ServiceAccount "olm-admin" in test namespace is cluster admin + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | webhook-operator | 0.0.1 | alpha | | StaticBundleDir(testdata/images/bundles/webhook-operator/v0.0.1) | + And ServiceAccount "olm-admin" in test namespace is cluster admin When ClusterExtension is applied """ apiVersion: olm.operatorframework.io/v1 @@ -373,10 +392,10 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: webhook-operator + packageName: ${PACKAGE:webhook-operator} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ Then ClusterExtension reports Progressing as False with Reason InvalidConfiguration and Message includes: """ @@ -386,7 +405,11 @@ Feature: Install ClusterExtension @BoxcutterRuntime @ProgressDeadline Scenario: Report ClusterExtension as not progressing if the rollout does not become available within given timeout - Given min value for ClusterExtension .spec.progressDeadlineMinutes is set to 1 + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.0.2 | alpha | | BadImage | + And ServiceAccount "olm-sa" with needed permissions is available in test namespace + And min value for ClusterExtension .spec.progressDeadlineMinutes is set to 1 And min value for ClusterObjectSet .spec.progressDeadlineMinutes is set to 1 When ClusterExtension is applied """ @@ -402,12 +425,12 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} # bundle refers bad image references, so that the deployment never becomes available version: 1.0.2 selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ Then ClusterObjectSet "${NAME}-1" reports Progressing as False with Reason ProgressDeadlineExceeded And ClusterExtension reports Progressing as False with Reason ProgressDeadlineExceeded and Message: @@ -419,7 +442,11 @@ Feature: Install ClusterExtension @BoxcutterRuntime @ProgressDeadline Scenario: Report ClusterExtension as not progressing if the rollout does not complete within given timeout - Given min value for ClusterExtension .spec.progressDeadlineMinutes is set to 1 + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.0.3 | alpha | | BadImage | + And ServiceAccount "olm-sa" with needed permissions is available in test namespace + And min value for ClusterExtension .spec.progressDeadlineMinutes is set to 1 And min value for ClusterObjectSet .spec.progressDeadlineMinutes is set to 1 When ClusterExtension is applied """ @@ -435,11 +462,11 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} version: 1.0.3 selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ Then ClusterObjectSet "${NAME}-1" reports Progressing as False with Reason ProgressDeadlineExceeded And ClusterExtension reports Progressing as False with Reason ProgressDeadlineExceeded and Message: @@ -450,6 +477,10 @@ Feature: Install ClusterExtension @BoxcutterRuntime Scenario: ClusterObjectSet is annotated with bundle properties + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.2.0 | beta | | CRD, Deployment, ConfigMap, Property(olm.test-property=some-value) | + And ServiceAccount "olm-sa" with needed permissions is available in test namespace When ClusterExtension is applied """ apiVersion: olm.operatorframework.io/v1 @@ -463,11 +494,11 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} version: 1.2.0 selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ # The annotation key and value come from the bundle's metadata/properties.yaml file Then ClusterObjectSet "${NAME}-1" contains annotation "olm.properties" with value @@ -477,6 +508,10 @@ Feature: Install ClusterExtension @BoxcutterRuntime Scenario: ClusterObjectSet is labeled with owner information + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.2.0 | beta | | CRD, Deployment, ConfigMap | + And ServiceAccount "olm-sa" with needed permissions is available in test namespace When ClusterExtension is applied """ apiVersion: olm.operatorframework.io/v1 @@ -490,11 +525,11 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} version: 1.2.0 selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ Then ClusterExtension is rolled out And ClusterExtension is available @@ -503,6 +538,10 @@ Feature: Install ClusterExtension @BoxcutterRuntime Scenario: ClusterObjectSet objects are externalized to immutable Secrets + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.2.0 | beta | | CRD, Deployment, ConfigMap | + And ServiceAccount "olm-sa" with needed permissions is available in test namespace When ClusterExtension is applied """ apiVersion: olm.operatorframework.io/v1 @@ -516,11 +555,11 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} version: 1.2.0 selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ Then ClusterExtension is rolled out And ClusterExtension is available @@ -536,6 +575,10 @@ Feature: Install ClusterExtension @DeploymentConfig Scenario: deploymentConfig nodeSelector is applied to the operator deployment + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.2.0 | beta | | CRD, Deployment, ConfigMap | + And ServiceAccount "olm-sa" with needed permissions is available in test namespace When ClusterExtension is applied """ apiVersion: olm.operatorframework.io/v1 @@ -555,12 +598,12 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ - Then resource "deployment/test-operator" matches + Then resource "deployment/test-operator-${SCENARIO_ID}" matches """ spec: template: @@ -571,6 +614,10 @@ Feature: Install ClusterExtension @BoxcutterRuntime Scenario: Install bundle with large CRD + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.0.0 | beta | | LargeCRD(250), Deployment | + And ServiceAccount "olm-sa" with needed permissions is available in test namespace When ClusterExtension is applied """ apiVersion: olm.operatorframework.io/v1 @@ -584,21 +631,23 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: large-crd-operator + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ Then ClusterExtension is rolled out And ClusterExtension is available - And bundle "large-crd-operator.1.0.0" is installed in version "1.0.0" - And resource "customresourcedefinition/largecrdtests.largecrd.operatorframework.io" is installed - And resource "deployment/large-crd-operator" is installed + And bundle "${PACKAGE:test}.1.0.0" is installed in version "1.0.0" + And resource "deployment/test-operator-${SCENARIO_ID}" is installed @BoxcutterRuntime @PreflightPermissions Scenario: Boxcutter preflight check detects missing CREATE permissions - Given ServiceAccount "olm-sa" without create permissions is available in test namespace + Given a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.2.0 | beta | | CRD, Deployment, ConfigMap | + And ServiceAccount "olm-sa" without create permissions is available in test namespace And ClusterExtension is applied """ apiVersion: olm.operatorframework.io/v1 @@ -612,10 +661,10 @@ Feature: Install ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ And ClusterExtension reports Progressing as True with Reason Retrying and Message includes: """ diff --git a/test/e2e/features/recover.feature b/test/e2e/features/recover.feature index b7610c5dfc..384924482d 100644 --- a/test/e2e/features/recover.feature +++ b/test/e2e/features/recover.feature @@ -2,7 +2,10 @@ Feature: Recover cluster extension from errors that might occur during its lifet Background: Given OLM is available - And ClusterCatalog "test" serves bundles + And an image registry is available + And a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.2.0 | beta | | CRD, Deployment, ConfigMap | Scenario: Restore removed resource Given ServiceAccount "olm-sa" with needed permissions is available in test namespace @@ -19,15 +22,15 @@ Feature: Recover cluster extension from errors that might occur during its lifet source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ And ClusterExtension is available - And resource "configmap/test-configmap" exists - When resource "configmap/test-configmap" is removed - Then resource "configmap/test-configmap" is eventually restored + And resource "configmap/test-configmap-${SCENARIO_ID}" exists + When resource "configmap/test-configmap-${SCENARIO_ID}" is removed + Then resource "configmap/test-configmap-${SCENARIO_ID}" is eventually restored Scenario: Install ClusterExtension after target namespace becomes available Given ClusterExtension is applied @@ -43,10 +46,10 @@ Feature: Recover cluster extension from errors that might occur during its lifet source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ And ClusterExtension reports Progressing as True with Reason Retrying When ServiceAccount "olm-sa" with needed permissions is available in test namespace @@ -60,17 +63,17 @@ Feature: Recover cluster extension from errors that might occur during its lifet apiVersion: apps/v1 kind: Deployment metadata: - name: test-operator + name: test-operator-${SCENARIO_ID} namespace: ${TEST_NAMESPACE} spec: replicas: 1 selector: matchLabels: - app: test-operator + app: test-operator-${SCENARIO_ID} template: metadata: labels: - app: test-operator + app: test-operator-${SCENARIO_ID} spec: containers: - command: @@ -103,14 +106,14 @@ Feature: Recover cluster extension from errors that might occur during its lifet source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ And ClusterExtension reports Progressing as True with Reason Retrying And ClusterExtension reports Installed as False - When resource "deployment/test-operator" is removed + When resource "deployment/test-operator-${SCENARIO_ID}" is removed Then ClusterExtension is available And ClusterExtension reports Progressing as True with Reason Succeeded And ClusterExtension reports Installed as True @@ -132,18 +135,18 @@ Feature: Recover cluster extension from errors that might occur during its lifet source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ And ClusterExtension reports Progressing as True with Reason Retrying and Message includes: """ - error for resolved bundle "test-operator.1.2.0" with version "1.2.0": creating new Revision: pre-authorization failed: service account requires the following permissions to manage cluster extension: + pre-authorization failed: service account requires the following permissions to manage cluster extension: """ And ClusterExtension reports Progressing as True with Reason Retrying and Message includes: """ - Namespace:"" APIGroups:[apiextensions.k8s.io] Resources:[customresourcedefinitions] ResourceNames:[olme2etests.olm.operatorframework.io] Verbs:[delete,get,patch,update] + Namespace:"" APIGroups:[apiextensions.k8s.io] Resources:[customresourcedefinitions] ResourceNames:[e2e-${SCENARIO_ID}tests.e2e-${SCENARIO_ID}.e2e.operatorframework.io] Verbs:[delete,get,patch,update] """ When ServiceAccount "olm-sa" with needed permissions is available in test namespace Then ClusterExtension is available @@ -151,7 +154,7 @@ Feature: Recover cluster extension from errors that might occur during its lifet And ClusterExtension reports Installed as True # CATALOG DELETION RESILIENCE SCENARIOS - + Scenario: Auto-healing continues working after catalog deletion # This test proves that extensions continue to auto-heal (restore deleted resources) even when # their source catalog is unavailable. We verify this by: @@ -177,19 +180,19 @@ Feature: Recover cluster extension from errors that might occur during its lifet source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ And ClusterExtension is rolled out And ClusterExtension is available - And resource "deployment/test-operator" is available - And resource "configmap/test-configmap" is available - When ClusterCatalog "test" is deleted - And resource "configmap/test-configmap" is removed - Then resource "configmap/test-configmap" is eventually restored - And resource "deployment/test-operator" is available + And resource "deployment/test-operator-${SCENARIO_ID}" is available + And resource "configmap/test-configmap-${SCENARIO_ID}" is available + When catalog "test" is deleted + And resource "configmap/test-configmap-${SCENARIO_ID}" is removed + Then resource "configmap/test-configmap-${SCENARIO_ID}" is eventually restored + And resource "deployment/test-operator-${SCENARIO_ID}" is available Scenario: Spec changes are allowed when catalog is unavailable # This test proves that users can modify extension configuration (non-version changes) even when @@ -217,14 +220,14 @@ Feature: Recover cluster extension from errors that might occur during its lifet source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ And ClusterExtension is rolled out And ClusterExtension is available - And ClusterCatalog "test" is deleted + And catalog "test" is deleted When ClusterExtension is updated to add preflight config """ apiVersion: olm.operatorframework.io/v1 @@ -242,10 +245,10 @@ Feature: Recover cluster extension from errors that might occur during its lifet source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ And ClusterExtension latest generation has been reconciled And ClusterExtension reports Progressing as True with Reason Succeeded diff --git a/test/e2e/features/status.feature b/test/e2e/features/status.feature index 01b0bf7a96..e3621ba623 100644 --- a/test/e2e/features/status.feature +++ b/test/e2e/features/status.feature @@ -5,7 +5,10 @@ Feature: Report status of the managed ClusterExtension workload Background: Given OLM is available - And ClusterCatalog "test" serves bundles + And an image registry is available + And a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.0.0 | alpha | | CRD, Deployment, ConfigMap | And ServiceAccount "olm-sa" with needed permissions is available in test namespace And ClusterExtension is applied """ @@ -20,10 +23,10 @@ Feature: Report status of the managed ClusterExtension workload source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} version: 1.0.0 """ And ClusterExtension is rolled out @@ -31,15 +34,15 @@ Feature: Report status of the managed ClusterExtension workload @BoxcutterRuntime Scenario: Report availability change when managed workload is not ready - When resource "deployment/test-operator" reports as not ready + When deployment "test-operator-${SCENARIO_ID}" reports as not ready Then ClusterExtension reports Available as False with Reason ProbeFailure And ClusterObjectSet "${NAME}-1" reports Available as False with Reason ProbeFailure @BoxcutterRuntime Scenario: Report availability change when managed workload restores its readiness - Given resource "deployment/test-operator" reports as not ready + Given deployment "test-operator-${SCENARIO_ID}" reports as not ready And ClusterExtension reports Available as False with Reason ProbeFailure And ClusterObjectSet "${NAME}-1" reports Available as False with Reason ProbeFailure - When resource "deployment/test-operator" reports as ready + When deployment "test-operator-${SCENARIO_ID}" reports as ready Then ClusterExtension is available - And ClusterObjectSet "${NAME}-1" reports Available as True with Reason ProbesSucceeded \ No newline at end of file + And ClusterObjectSet "${NAME}-1" reports Available as True with Reason ProbesSucceeded diff --git a/test/e2e/features/uninstall.feature b/test/e2e/features/uninstall.feature index 89290ada68..7401ce1663 100644 --- a/test/e2e/features/uninstall.feature +++ b/test/e2e/features/uninstall.feature @@ -5,7 +5,10 @@ Feature: Uninstall ClusterExtension Background: Given OLM is available - And ClusterCatalog "test" serves bundles + And an image registry is available + And a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.2.0 | beta | | CRD, Deployment, ConfigMap | And ServiceAccount "olm-sa" with needed permissions is available in test namespace And ClusterExtension is applied """ @@ -20,12 +23,12 @@ Feature: Uninstall ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ - And bundle "test-operator.1.2.0" is installed in version "1.2.0" + And bundle "${PACKAGE:test}.1.2.0" is installed in version "1.2.0" And ClusterExtension is rolled out And ClusterExtension resources are created and labeled diff --git a/test/e2e/features/update.feature b/test/e2e/features/update.feature index ab9408365e..7815ba8733 100644 --- a/test/e2e/features/update.feature +++ b/test/e2e/features/update.feature @@ -5,7 +5,15 @@ Feature: Update ClusterExtension Background: Given OLM is available - And ClusterCatalog "test" serves bundles + And an image registry is available + And a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.0.0 | alpha | | CRD, Deployment, ConfigMap | + | test | 1.0.0 | beta | | | + | test | 1.0.1 | beta | 1.0.0 | CRD, Deployment, ConfigMap | + | test | 1.0.2 | alpha | 1.0.0 | BadImage | + | test | 1.0.4 | beta | | CRD, Deployment, ConfigMap | + | test | 1.2.0 | beta | 1.0.1 | CRD, Deployment, ConfigMap | And ServiceAccount "olm-sa" with needed permissions is available in test namespace Scenario: Update to a successor version @@ -22,10 +30,10 @@ Feature: Update ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} version: 1.0.0 """ And ClusterExtension is rolled out @@ -33,7 +41,7 @@ Feature: Update ClusterExtension When ClusterExtension is updated to version "1.0.1" Then ClusterExtension is rolled out And ClusterExtension is available - And bundle "test-operator.1.0.1" is installed in version "1.0.1" + And bundle "${PACKAGE:test}.1.0.1" is installed in version "1.0.1" Scenario: Cannot update extension to non successor version Given ClusterExtension is applied @@ -49,10 +57,10 @@ Feature: Update ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} version: 1.0.0 """ And ClusterExtension is rolled out @@ -70,15 +78,15 @@ Feature: Update ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} version: 1.2.0 """ Then ClusterExtension reports Progressing as True with Reason Retrying and Message: """ - error upgrading from currently installed version "1.0.0": no bundles found for package "test" matching version "1.2.0" + error upgrading from currently installed version "1.0.0": no bundles found for package "${PACKAGE:test}" matching version "1.2.0" """ Scenario: Force update to non successor version @@ -95,10 +103,10 @@ Feature: Update ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} version: 1.0.0 """ And ClusterExtension is rolled out @@ -116,16 +124,16 @@ Feature: Update ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} version: 1.2.0 upgradeConstraintPolicy: SelfCertified """ Then ClusterExtension is rolled out And ClusterExtension is available - And bundle "test-operator.1.2.0" is installed in version "1.2.0" + And bundle "${PACKAGE:test}.1.2.0" is installed in version "1.2.0" @catalog-updates Scenario: Auto update when new version becomes available in the new catalog image ref @@ -142,20 +150,23 @@ Feature: Update ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ And ClusterExtension is rolled out And ClusterExtension is available - And bundle "test-operator.1.2.0" is installed in version "1.2.0" - When ClusterCatalog "test" is updated to version "v2" - Then bundle "test-operator.1.3.0" is installed in version "1.3.0" - + And bundle "${PACKAGE:test}.1.2.0" is installed in version "1.2.0" + And catalog "test" version "v2" with packages: + | package | version | channel | replaces | contents | + | test | 1.3.0 | beta | 1.2.0 | CRD, Deployment, ConfigMap | + When catalog "test" is updated to version "v2" + Then bundle "${PACKAGE:test}.1.3.0" is installed in version "1.3.0" + Scenario: Auto update when new version becomes available in the same catalog image ref - Given "test" catalog image version "v1" is also tagged as "latest" - And ClusterCatalog "test" is updated to version "latest" + Given catalog "test" image version "v1" is also tagged as "latest" + And catalog "test" is updated to version "latest" And ClusterExtension is applied """ apiVersion: olm.operatorframework.io/v1 @@ -169,16 +180,19 @@ Feature: Update ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ And ClusterExtension is rolled out And ClusterExtension is available - And bundle "test-operator.1.2.0" is installed in version "1.2.0" - When ClusterCatalog "test" image version "v2" is also tagged as "latest" - Then bundle "test-operator.1.3.0" is installed in version "1.3.0" + And bundle "${PACKAGE:test}.1.2.0" is installed in version "1.2.0" + And catalog "test" version "v2" with packages: + | package | version | channel | replaces | contents | + | test | 1.3.0 | beta | 1.2.0 | CRD, Deployment, ConfigMap | + When catalog "test" image version "v2" is also tagged as "latest" + Then bundle "${PACKAGE:test}.1.3.0" is installed in version "1.3.0" @BoxcutterRuntime Scenario: Update to a version with identical bundle content creates a new revision @@ -195,20 +209,20 @@ Feature: Update ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} version: 1.0.0 upgradeConstraintPolicy: SelfCertified """ And ClusterExtension is rolled out And ClusterExtension is available - And bundle "test-operator.1.0.0" is installed in version "1.0.0" + And bundle "${PACKAGE:test}.1.0.0" is installed in version "1.0.0" When ClusterExtension is updated to version "1.0.4" Then ClusterExtension is rolled out And ClusterExtension is available - And bundle "test-operator.1.0.4" is installed in version "1.0.4" + And bundle "${PACKAGE:test}.1.0.4" is installed in version "1.0.4" @BoxcutterRuntime Scenario: Detect collision when a second ClusterExtension installs the same package after an upgrade @@ -225,10 +239,10 @@ Feature: Update ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} version: 1.0.0 """ And ClusterExtension is rolled out @@ -236,7 +250,7 @@ Feature: Update ClusterExtension When ClusterExtension is updated to version "1.0.1" Then ClusterExtension is rolled out And ClusterExtension is available - And bundle "test-operator.1.0.1" is installed in version "1.0.1" + And bundle "${PACKAGE:test}.1.0.1" is installed in version "1.0.1" And the current ClusterExtension is tracked for cleanup When ClusterExtension is applied """ @@ -251,10 +265,10 @@ Feature: Update ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} version: 1.0.1 """ Then ClusterExtension reports Progressing as True with Reason Retrying and Message includes: @@ -277,17 +291,17 @@ Feature: Update ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} version: 1.0.0 upgradeConstraintPolicy: SelfCertified """ And ClusterExtension is rolled out And ClusterExtension is available When ClusterExtension is updated to version "1.2.0" - Then bundle "test-operator.1.2.0" is installed in version "1.2.0" + Then bundle "${PACKAGE:test}.1.2.0" is installed in version "1.2.0" And ClusterExtension is rolled out And ClusterExtension is available And ClusterExtension reports "${NAME}-2" as active revision @@ -311,10 +325,10 @@ Feature: Update ClusterExtension source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} version: 1.0.0 upgradeConstraintPolicy: SelfCertified """ @@ -324,4 +338,3 @@ Feature: Update ClusterExtension Then ClusterExtension reports "${NAME}-1, ${NAME}-2" as active revisions And ClusterObjectSet "${NAME}-2" reports Progressing as True with Reason RollingOut And ClusterObjectSet "${NAME}-2" reports Available as False with Reason ProbeFailure - diff --git a/test/e2e/features/user-managed-fields.feature b/test/e2e/features/user-managed-fields.feature index 6c830bbe34..cdd00317c2 100644 --- a/test/e2e/features/user-managed-fields.feature +++ b/test/e2e/features/user-managed-fields.feature @@ -6,7 +6,10 @@ Feature: Preserve user-managed fields on deployed resources Background: Given OLM is available - And ClusterCatalog "test" serves bundles + And an image registry is available + And a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.2.0 | beta | | CRD, Deployment, ConfigMap | And ServiceAccount "olm-sa" with needed permissions is available in test namespace And ClusterExtension is applied """ @@ -21,42 +24,42 @@ Feature: Preserve user-managed fields on deployed resources source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} """ And ClusterExtension is rolled out And ClusterExtension is available - And resource "deployment/test-operator" is available + And resource "deployment/test-operator-${SCENARIO_ID}" is available Scenario: User-added annotations and labels coexist with bundle-defined labels after reconciliation # The bundle defines labels on the deployment via the CSV spec; verify they are present - Given resource "deployment/test-operator" has labels - | key | value | - | app.kubernetes.io/name | test-operator | - When annotations are added to "deployment/test-operator" + Given resource "deployment/test-operator-${SCENARIO_ID}" has labels + | key | value | + | app.kubernetes.io/name | test-operator-${SCENARIO_ID} | + When annotations are added to "deployment/test-operator-${SCENARIO_ID}" | key | value | | example.com/custom-annotation | my-value | - And labels are added to "deployment/test-operator" + And labels are added to "deployment/test-operator-${SCENARIO_ID}" | key | value | | example.com/custom-label | my-value | And ClusterExtension reconciliation is triggered And ClusterExtension has been reconciled the latest generation - Then resource "deployment/test-operator" has annotations + Then resource "deployment/test-operator-${SCENARIO_ID}" has annotations | key | value | | example.com/custom-annotation | my-value | - And resource "deployment/test-operator" has labels - | key | value | - | example.com/custom-label | my-value | - | app.kubernetes.io/name | test-operator | + And resource "deployment/test-operator-${SCENARIO_ID}" has labels + | key | value | + | example.com/custom-label | my-value | + | app.kubernetes.io/name | test-operator-${SCENARIO_ID} | Scenario: Deployment rollout restart persists after OLM reconciliation - When rollout restart is performed on "deployment/test-operator" - Then deployment "test-operator" pod template has annotation "kubectl.kubernetes.io/restartedAt" - And deployment "test-operator" rollout is complete - And deployment "test-operator" has 2 replica sets + When rollout restart is performed on "deployment/test-operator-${SCENARIO_ID}" + Then deployment "test-operator-${SCENARIO_ID}" pod template has annotation "kubectl.kubernetes.io/restartedAt" + And deployment "test-operator-${SCENARIO_ID}" rollout is complete + And deployment "test-operator-${SCENARIO_ID}" has 2 replica sets When ClusterExtension reconciliation is triggered And ClusterExtension has been reconciled the latest generation - Then deployment "test-operator" pod template has annotation "kubectl.kubernetes.io/restartedAt" - And deployment "test-operator" rollout is complete + Then deployment "test-operator-${SCENARIO_ID}" pod template has annotation "kubectl.kubernetes.io/restartedAt" + And deployment "test-operator-${SCENARIO_ID}" rollout is complete diff --git a/test/e2e/steps/hooks.go b/test/e2e/steps/hooks.go index 556a99638d..e78df3a048 100644 --- a/test/e2e/steps/hooks.go +++ b/test/e2e/steps/hooks.go @@ -8,6 +8,7 @@ import ( "os/exec" "regexp" "strconv" + "sync" "github.com/cucumber/godog" "github.com/go-logr/logr" @@ -40,10 +41,10 @@ type scenarioContext struct { namespace string clusterExtensionName string clusterObjectSetName string - clusterCatalogName string + catalogs map[string]string // user-chosen name -> ClusterCatalog resource name + catalogPackageNames map[string]string // original package name -> parameterized name addedResources []resource removedResources []unstructured.Unstructured - backGroundCmds []*exec.Cmd metricsResponse map[string]string leaderPods map[string]string // component name -> leader pod name deploymentRestores []deploymentRestore @@ -167,6 +168,9 @@ func CreateScenarioContext(ctx context.Context, sc *godog.Scenario) (context.Con namespace: fmt.Sprintf("ns-%s", sc.Id), clusterExtensionName: fmt.Sprintf("ce-%s", sc.Id), clusterObjectSetName: fmt.Sprintf("cos-%s", sc.Id), + catalogs: make(map[string]string), + catalogPackageNames: make(map[string]string), + metricsResponse: make(map[string]string), leaderPods: make(map[string]string), } return context.WithValue(ctx, scenarioContextKey, scCtx), nil @@ -186,12 +190,6 @@ func stderrOutput(err error) string { func ScenarioCleanup(ctx context.Context, _ *godog.Scenario, err error) (context.Context, error) { sc := scenarioCtx(ctx) - for _, bgCmd := range sc.backGroundCmds { - if p := bgCmd.Process; p != nil { - _ = p.Kill() - } - } - // Always restore deployments whose args were modified during the scenario, // even when the scenario failed, so that a misconfigured TLS profile does // not leak into subsequent scenarios. Restore in reverse order so that @@ -219,9 +217,16 @@ func ScenarioCleanup(ctx context.Context, _ *godog.Scenario, err error) (context if sc.clusterObjectSetName != "" { forDeletion = append(forDeletion, resource{name: sc.clusterObjectSetName, kind: "clusterobjectset"}) } + for _, catalogName := range sc.catalogs { + forDeletion = append(forDeletion, resource{name: catalogName, kind: "clustercatalog"}) + } forDeletion = append(forDeletion, resource{name: sc.namespace, kind: "namespace"}) + + var wg sync.WaitGroup for _, r := range forDeletion { + wg.Add(1) go func(res resource) { + defer wg.Done() args := []string{"delete", res.kind, res.name, "--ignore-not-found=true"} if res.namespace != "" { args = append(args, "-n", res.namespace) @@ -231,5 +236,6 @@ func ScenarioCleanup(ctx context.Context, _ *godog.Scenario, err error) (context } }(r) } + wg.Wait() return ctx, nil } diff --git a/test/e2e/steps/steps.go b/test/e2e/steps/steps.go index 9a6a63fa3b..3f1dedb258 100644 --- a/test/e2e/steps/steps.go +++ b/test/e2e/steps/steps.go @@ -15,6 +15,7 @@ import ( "path/filepath" "reflect" "runtime" + "strconv" "strings" "sync" "time" @@ -36,11 +37,16 @@ import ( k8sresource "k8s.io/cli-runtime/pkg/resource" "k8s.io/component-base/featuregate" "k8s.io/utils/ptr" + ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/yaml" + "github.com/operator-framework/api/pkg/operators/v1alpha1" + ocv1 "github.com/operator-framework/operator-controller/api/v1" "github.com/operator-framework/operator-controller/internal/operator-controller/features" + "github.com/operator-framework/operator-controller/test/internal/catalog" + testregistry "github.com/operator-framework/operator-controller/test/internal/registry" ) const ( @@ -54,24 +60,40 @@ var ( kubeconfigPath string k8sCli string deployImageRegistry = sync.OnceValue(func() error { - if os.Getenv("KIND_CLUSTER_NAME") == "" { + // Only deploy the registry on kind clusters + providerID, err := k8sClient("get", "nodes", "-o", "jsonpath={.items[0].spec.providerID}") + if err != nil || !strings.HasPrefix(providerID, "kind://") { return nil } - cmd := exec.Command("bash", "-c", "make image-registry") - dir, _ := os.LookupEnv("ROOT_DIR") - if dir == "" { - return fmt.Errorf("ROOT_DIR environment variable not set") + + cfg, err := ctrl.GetConfig() + if err != nil { + return fmt.Errorf("failed to get kubeconfig: %w", err) } - cmd.Dir = dir - cmd.Env = append(os.Environ(), fmt.Sprintf("KUBECONFIG=%s", kubeconfigPath)) - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - return cmd.Run() + return testregistry.Deploy(context.Background(), cfg, testregistry.DefaultNamespace, testregistry.DefaultName) + }) + startRegistryPortForward = sync.OnceValues(func() (string, error) { + if err := deployImageRegistry(); err != nil { + return "", err + } + cfg, err := ctrl.GetConfig() + if err != nil { + return "", fmt.Errorf("failed to get kubeconfig: %w", err) + } + // Port-forward lives for the duration of the test process; + // the stop function is not needed because the goroutine is + // cleaned up on process exit. + localAddr, _, err := testregistry.PortForward(context.Background(), cfg, testregistry.DefaultNamespace, testregistry.DefaultName) + if err != nil { + return "", fmt.Errorf("failed to start port-forward to registry: %w", err) + } + return localAddr, nil }) ) func RegisterSteps(sc *godog.ScenarioContext) { sc.Step(`^OLM is available$`, OLMisAvailable) + sc.Step(`^(?i)an image registry is available$`, ImageRegistryIsAvailable) sc.Step(`^(?i)bundle "([^"]+)" is installed in version "([^"]+)"$`, BundleInstalled) sc.Step(`^(?i)ClusterExtension is applied(?:\s+.*)?$`, ResourceIsApplied) @@ -112,7 +134,7 @@ func RegisterSteps(sc *godog.ScenarioContext) { sc.Step(`^(?i)resource "([^"]+)" is (?:eventually not found|not installed)$`, ResourceEventuallyNotFound) sc.Step(`^(?i)resource "([^"]+)" exists$`, ResourceAvailable) sc.Step(`^(?i)resource is applied$`, ResourceIsApplied) - sc.Step(`^(?i)resource "deployment/test-operator" reports as (not ready|ready)$`, MarkTestOperatorNotReady) + sc.Step(`^(?i)deployment "([^"]+)" reports as (not ready|ready)$`, MarkDeploymentReadiness) sc.Step(`^(?i)resource apply fails with error msg containing "([^"]+)"$`, ResourceApplyFails) sc.Step(`^(?i)resource "([^"]+)" is eventually restored$`, ResourceRestored) @@ -135,13 +157,11 @@ func RegisterSteps(sc *godog.ScenarioContext) { sc.Step(`^(?i)ServiceAccount "([^"]+)" in test namespace has permissions to fetch "([^"]+)" metrics$`, ServiceAccountWithFetchMetricsPermissions) sc.Step(`^(?i)ServiceAccount "([^"]+)" sends request to "([^"]+)" endpoint of "([^"]+)" service$`, SendMetricsRequest) - sc.Step(`^"([^"]+)" catalog is updated to version "([^"]+)"$`, CatalogIsUpdatedToVersion) - sc.Step(`^(?i)ClusterCatalog "([^"]+)" is updated to version "([^"]+)"$`, CatalogIsUpdatedToVersion) - sc.Step(`^"([^"]+)" catalog serves bundles$`, CatalogServesBundles) - sc.Step(`^(?i)ClusterCatalog "([^"]+)" serves bundles$`, CatalogServesBundles) - sc.Step(`^"([^"]+)" catalog image version "([^"]+)" is also tagged as "([^"]+)"$`, TagCatalogImage) - sc.Step(`^(?i)ClusterCatalog "([^"]+)" image version "([^"]+)" is also tagged as "([^"]+)"$`, TagCatalogImage) - sc.Step(`^(?i)ClusterCatalog "([^"]+)" is deleted$`, CatalogIsDeleted) + sc.Step(`^(?i)catalog "([^"]+)" is deleted$`, ScenarioCatalogIsDeleted) + sc.Step(`^(?i)catalog "([^"]+)" is updated to version "([^"]+)"$`, ScenarioCatalogIsUpdatedToVersion) + sc.Step(`^(?i)catalog "([^"]+)" version "([^"]+)" with packages:$`, CatalogVersionWithPackages) + sc.Step(`^(?i)catalog "([^"]+)" image version "([^"]+)" is also tagged as "([^"]+)"$`, ScenarioCatalogTagImage) + sc.Step(`^(?i)a catalog "([^"]+)" with packages:$`, CatalogWithPackages) sc.Step(`^(?i)operator "([^"]+)" target namespace is "([^"]+)"$`, OperatorTargetNamespace) sc.Step(`^(?i)Prometheus metrics are returned in the response$`, PrometheusMetricsAreReturned) @@ -167,8 +187,9 @@ func RegisterSteps(sc *godog.ScenarioContext) { sc.Step(`^(?i)OLM is upgraded$`, OLMIsUpgraded) sc.Step(`^(?i)(catalogd|operator-controller) is ready to reconcile resources$`, ComponentIsReadyToReconcile) sc.Step(`^(?i)all (ClusterCatalog|ClusterExtension) resources are reconciled$`, allResourcesAreReconciled) - sc.Step(`^(?i)(ClusterCatalog|ClusterExtension) is reconciled$`, ResourceTypeIsReconciled) - sc.Step(`^(?i)ClusterCatalog reports ([[:alnum:]]+) as ([[:alnum:]]+) with Reason ([[:alnum:]]+)$`, ClusterCatalogReportsCondition) + sc.Step(`^(?i)ClusterExtension is reconciled$`, ClusterExtensionIsReconciled) + sc.Step(`^(?i)catalog "([^"]+)" is reconciled$`, ScenarioCatalogIsReconciled) + sc.Step(`^(?i)catalog "([^"]+)" reports ([[:alnum:]]+) as ([[:alnum:]]+) with Reason ([[:alnum:]]+)$`, ScenarioCatalogReportsCondition) } func init() { @@ -206,6 +227,43 @@ func k8scliWithInput(yaml string, args ...string) (string, error) { return string(b), err } +// projectRootDir finds the project root by walking up from the source file until go.mod is found. +func projectRootDir() string { + _, thisFile, _, _ := runtime.Caller(0) + dir := filepath.Dir(thisFile) + for { + if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil { + return dir + } + parent := filepath.Dir(dir) + if parent == dir { + panic("could not find project root (no go.mod found)") + } + dir = parent + } +} + +// registryHosts returns the local and in-cluster registry addresses. +// The local address is obtained by port-forwarding to the in-cluster registry, +// which works regardless of the cluster's network topology. +func registryHosts() (string, string, error) { + local, err := startRegistryPortForward() + if err != nil { + return "", "", fmt.Errorf("failed to get local registry address: %w", err) + } + cluster := os.Getenv("CLUSTER_REGISTRY_HOST") + if cluster == "" { + cluster = "docker-registry.operator-controller-e2e.svc.cluster.local:5000" + } + return local, cluster, nil +} + +// ImageRegistryIsAvailable ensures the in-cluster image registry is deployed and ready. +// This is needed for scenarios that build and push per-scenario catalog images. +func ImageRegistryIsAvailable() error { + return deployImageRegistry() +} + // OLMisAvailable waits for the OLM operator-controller deployment to become available. Polls with timeout. func OLMisAvailable(ctx context.Context) error { require.Eventually(godog.T(ctx), func() bool { @@ -221,6 +279,7 @@ func OLMisAvailable(ctx context.Context) error { // BundleInstalled waits for the ClusterExtension to report the specified bundle name and version as installed. Polls with timeout. func BundleInstalled(ctx context.Context, name, version string) error { sc := scenarioCtx(ctx) + name = substituteScenarioVars(name, sc) waitFor(ctx, func() bool { v, err := k8sClient("get", "clusterextension", sc.clusterExtensionName, "-o", "jsonpath={.status.install.bundle}") if err != nil { @@ -248,10 +307,13 @@ func substituteScenarioVars(content string, sc *scenarioContext) string { "TEST_NAMESPACE": sc.namespace, "NAME": sc.clusterExtensionName, "COS_NAME": sc.clusterObjectSetName, - "CATALOG_IMG": "docker-registry.operator-controller-e2e.svc.cluster.local:5000/e2e/test-catalog:v1", + "SCENARIO_ID": sc.id, } - if v, found := os.LookupEnv("CATALOG_IMG"); found { - vars["CATALOG_IMG"] = v + for orig, param := range sc.catalogPackageNames { + vars[fmt.Sprintf("PACKAGE:%s", orig)] = param + } + for name, catalogName := range sc.catalogs { + vars[fmt.Sprintf("CATALOG:%s", name)] = catalogName } return templateContent(content, vars) } @@ -877,13 +939,10 @@ func ClusterObjectSetReferredSecretsContainLabels(ctx context.Context, revisionN sc := scenarioCtx(ctx) revisionName = substituteScenarioVars(strings.TrimSpace(revisionName), sc) - expected, err := parseKeyValueTable(table) + expected, err := parseKeyValueTable(table, sc) if err != nil { return fmt.Errorf("invalid labels table: %w", err) } - for k, v := range expected { - expected[k] = substituteScenarioVars(v, sc) - } waitFor(ctx, func() bool { secrets, err := listReferredSecrets(ctx, revisionName) @@ -1181,17 +1240,33 @@ func applyPermissionsToServiceAccount(ctx context.Context, serviceAccount, rbacT }, keyValue...) _, thisFile, _, _ := runtime.Caller(0) - yaml, err := templateYaml(filepath.Join(filepath.Dir(thisFile), "testdata", rbacTemplate), vars) + rbacYaml, err := templateYaml(filepath.Join(filepath.Dir(thisFile), "testdata", rbacTemplate), vars) if err != nil { return fmt.Errorf("failed to template RBAC yaml: %v", err) } // Apply the RBAC configuration - _, err = k8scliWithInput(yaml, "apply", "-f", "-") + _, err = k8scliWithInput(rbacYaml, "apply", "-f", "-") if err != nil { return fmt.Errorf("failed to apply RBAC configuration: %v: %s", err, stderrOutput(err)) } + // Track cluster-scoped RBAC resources for cleanup + for _, doc := range strings.Split(rbacYaml, "---") { + doc = strings.TrimSpace(doc) + if doc == "" { + continue + } + res, err := toUnstructured(doc) + if err != nil { + continue + } + kind := res.GetKind() + if kind == "ClusterRole" || kind == "ClusterRoleBinding" { + sc.addedResources = append(sc.addedResources, resource{name: res.GetName(), kind: strings.ToLower(kind)}) + } + } + return nil } @@ -1231,6 +1306,7 @@ func ServiceAccountWithoutCreatePermissionsIsAvailableInTestNamespace(ctx contex // ServiceAccountWithNeededPermissionsIsAvailableInGivenNamespace creates a ServiceAccount and enables creation of any cluster extension on behalf of this account. func ServiceAccountWithNeededPermissionsIsAvailableInGivenNamespace(ctx context.Context, serviceAccount string, ns string) error { sc := scenarioCtx(ctx) + ns = substituteScenarioVars(ns, sc) sc.addedResources = append(sc.addedResources, resource{name: ns, kind: "namespace"}) if err := applyServiceAccount(ctx, serviceAccount, "TEST_NAMESPACE", ns); err != nil { return err @@ -1361,9 +1437,58 @@ func SendMetricsRequest(ctx context.Context, serviceAccount string, endpoint str return nil } -// CatalogIsUpdatedToVersion patches the ClusterCatalog's image reference to the specified version tag. -func CatalogIsUpdatedToVersion(name, version string) error { - ref, err := k8sClient("get", "clustercatalog", fmt.Sprintf("%s-catalog", name), "-o", "jsonpath={.spec.source.image.ref}") +// ScenarioCatalogIsDeleted deletes a named per-scenario ClusterCatalog and waits for it to be removed. +func ScenarioCatalogIsDeleted(ctx context.Context, catalogUserName string) error { + sc := scenarioCtx(ctx) + catalogName, ok := sc.catalogs[catalogUserName] + if !ok { + return fmt.Errorf("no catalog %q has been created for this scenario", catalogUserName) + } + _, err := k8sClient("delete", "clustercatalog", catalogName, "--ignore-not-found=true", "--wait=true") + if err != nil { + return fmt.Errorf("failed to delete catalog %q: %v", catalogUserName, err) + } + return nil +} + +// CatalogVersionWithPackages builds an additional version of a per-scenario catalog image. +// It pushes a new catalog image with the specified tag but does NOT update the ClusterCatalog. +// Use ScenarioCatalogIsUpdatedToVersion to patch the ClusterCatalog to use the new version. +func CatalogVersionWithPackages(ctx context.Context, catalogUserName, version string, table *godog.Table) error { + sc := scenarioCtx(ctx) + + pkgOpts, err := parseCatalogTable(table) + if err != nil { + return err + } + + cat := catalog.NewCatalog(catalogUserName, sc.id, pkgOpts...) + localRegistry, clusterRegistry, err := registryHosts() + if err != nil { + return err + } + + result, err := cat.Build(ctx, version, localRegistry, clusterRegistry) + if err != nil { + return fmt.Errorf("failed to build catalog version %s: %w", version, err) + } + + // Accumulate package names (bundles may differ between versions) + for orig, param := range result.PackageNames { + sc.catalogPackageNames[orig] = param + } + + return nil +} + +// ScenarioCatalogIsUpdatedToVersion patches a named per-scenario ClusterCatalog's image ref to a new version tag. +func ScenarioCatalogIsUpdatedToVersion(ctx context.Context, catalogUserName, version string) error { + sc := scenarioCtx(ctx) + catalogName, ok := sc.catalogs[catalogUserName] + if !ok { + return fmt.Errorf("no catalog %q has been created for this scenario", catalogUserName) + } + ref, err := k8sClient("get", "clustercatalog", catalogName, "-o", "jsonpath={.spec.source.image.ref}") if err != nil { return err } @@ -1385,48 +1510,196 @@ func CatalogIsUpdatedToVersion(name, version string) error { if err != nil { return err } - _, err = k8sClient("patch", "clustercatalog", fmt.Sprintf("%s-catalog", name), "--type", "merge", "-p", string(pb)) + _, err = k8sClient("patch", "clustercatalog", catalogName, "--type", "merge", "-p", string(pb)) return err } -// CatalogServesBundles applies the ClusterCatalog YAML template to create a catalog that serves bundles. -func CatalogServesBundles(ctx context.Context, catalogName string) error { - if err := deployImageRegistry(); err != nil { +// ScenarioCatalogTagImage tags an existing per-scenario catalog image with a new tag. +func ScenarioCatalogTagImage(ctx context.Context, catalogUserName, oldTag, newTag string) error { + localRegistry, _, err := registryHosts() + if err != nil { return err } sc := scenarioCtx(ctx) - sc.clusterCatalogName = fmt.Sprintf("%s-catalog", catalogName) + imageRef := fmt.Sprintf("%s/e2e/%s-catalog-%s:%s", localRegistry, catalogUserName, sc.id, oldTag) + return crane.Tag(imageRef, newTag, crane.Insecure) +} - _, thisFile, _, _ := runtime.Caller(0) - yamlContent, err := os.ReadFile(filepath.Join(filepath.Dir(thisFile), "testdata", fmt.Sprintf("%s-catalog-template.yaml", catalogName))) - if err != nil { - return fmt.Errorf("failed to read catalog yaml: %v", err) +// parseCatalogTable parses a Gherkin data table into catalog.PackageOption slices. +// Table columns: package | version | channel | replaces | contents +func parseCatalogTable(table *godog.Table) ([]catalog.PackageOption, error) { + type bundleKey struct { + pkg string + version string + } + type bundleEntry struct { + opts []catalog.BundleOption + } + type channelEntry struct { + version string + replaces string } - _, err = k8scliWithInput(substituteScenarioVars(string(yamlContent), sc), "apply", "-f", "-") - if err != nil { - return fmt.Errorf("failed to apply catalog: %v", err) + bundleDefs := make(map[bundleKey]*bundleEntry) + var bundleOrder []bundleKey + packageChannels := make(map[string]map[string][]channelEntry) + var packageOrder []string + packageSeen := make(map[string]bool) + + for _, row := range table.Rows[1:] { // skip header + pkg := row.Cells[0].Value + version := row.Cells[1].Value + channel := row.Cells[2].Value + replaces := row.Cells[3].Value + contents := row.Cells[4].Value + + if !packageSeen[pkg] { + packageOrder = append(packageOrder, pkg) + packageSeen[pkg] = true + } + + bk := bundleKey{pkg: pkg, version: version} + if _, exists := bundleDefs[bk]; exists { + if strings.TrimSpace(contents) != "" { + return nil, fmt.Errorf("duplicate bundle %s/%s: contents must be empty for repeated versions", pkg, version) + } + } else { + opts := parseContents(contents) + bundleDefs[bk] = &bundleEntry{opts: opts} + bundleOrder = append(bundleOrder, bk) + } + + if packageChannels[pkg] == nil { + packageChannels[pkg] = make(map[string][]channelEntry) + } + packageChannels[pkg][channel] = append(packageChannels[pkg][channel], channelEntry{ + version: version, + replaces: replaces, + }) } - return nil -} + var pkgOpts []catalog.PackageOption + for _, pkgName := range packageOrder { + var opts []catalog.PackageOption -// TagCatalogImage adds a new tag to a catalog container image in the local registry using crane. -func TagCatalogImage(name, oldTag, newTag string) error { - imageRef := fmt.Sprintf("%s/%s", os.Getenv("LOCAL_REGISTRY_HOST"), fmt.Sprintf("e2e/%s-catalog:%s", name, oldTag)) - return crane.Tag(imageRef, newTag, crane.Insecure) + for _, bk := range bundleOrder { + if bk.pkg == pkgName { + opts = append(opts, catalog.Bundle(bk.version, bundleDefs[bk].opts...)) + } + } + + for chName, entries := range packageChannels[pkgName] { + var chOpts []catalog.ChannelOption + for _, e := range entries { + if e.replaces != "" { + chOpts = append(chOpts, catalog.Entry(e.version, catalog.Replaces(e.replaces))) + } else { + chOpts = append(chOpts, catalog.Entry(e.version)) + } + } + opts = append(opts, catalog.Channel(chName, chOpts...)) + } + + pkgOpts = append(pkgOpts, catalog.WithPackage(pkgName, opts...)) + } + return pkgOpts, nil } -// CatalogIsDeleted deletes the named ClusterCatalog resource and waits for it to be removed. -func CatalogIsDeleted(ctx context.Context, catalogName string) error { - catalogFullName := fmt.Sprintf("%s-catalog", catalogName) - _, err := k8sClient("delete", "clustercatalog", catalogFullName, "--ignore-not-found=true", "--wait=true") +// CatalogWithPackages builds a per-scenario catalog from a Gherkin data table. +// Table columns: package | version | channel | replaces | contents +func CatalogWithPackages(ctx context.Context, catalogUserName string, table *godog.Table) error { + sc := scenarioCtx(ctx) + + pkgOpts, err := parseCatalogTable(table) + if err != nil { + return err + } + + cat := catalog.NewCatalog(catalogUserName, sc.id, pkgOpts...) + localRegistry, clusterRegistry, err := registryHosts() + if err != nil { + return err + } + + result, err := cat.Build(ctx, "v1", localRegistry, clusterRegistry) if err != nil { - return fmt.Errorf("failed to delete catalog: %v", err) + return fmt.Errorf("failed to build catalog: %w", err) } + + sc.catalogs[catalogUserName] = result.CatalogName + for orig, param := range result.PackageNames { + sc.catalogPackageNames[orig] = param + } + + catalogYAML := fmt.Sprintf(`apiVersion: olm.operatorframework.io/v1 +kind: ClusterCatalog +metadata: + name: %s +spec: + priority: 0 + source: + type: Image + image: + pollIntervalMinutes: 1 + ref: %s +`, result.CatalogName, result.CatalogImageRef) + + if _, err := k8scliWithInput(catalogYAML, "apply", "-f", "-"); err != nil { + return fmt.Errorf("failed to apply ClusterCatalog: %w", err) + } + return nil } +func parseContents(contents string) []catalog.BundleOption { + contents = strings.TrimSpace(contents) + if contents == "" { + return nil + } + if strings.EqualFold(contents, "BadImage") { + return []catalog.BundleOption{catalog.BadImage()} + } + var opts []catalog.BundleOption + for _, part := range strings.Split(contents, ",") { + part = strings.TrimSpace(part) + switch { + case part == "CRD": + opts = append(opts, catalog.WithCRD()) + case part == "Deployment": + opts = append(opts, catalog.WithDeployment()) + case part == "ConfigMap": + opts = append(opts, catalog.WithConfigMap()) + case strings.HasPrefix(part, "Property(") && strings.HasSuffix(part, ")"): + // Property(type=value) + inner := part[len("Property(") : len(part)-1] + if k, v, ok := strings.Cut(inner, "="); ok { + opts = append(opts, catalog.WithBundleProperty(k, v)) + } + case strings.HasPrefix(part, "InstallMode(") && strings.HasSuffix(part, ")"): + // InstallMode(SingleNamespace) or InstallMode(OwnNamespace) + mode := part[len("InstallMode(") : len(part)-1] + opts = append(opts, catalog.WithInstallMode(v1alpha1.InstallModeType(mode))) + case strings.HasPrefix(part, "LargeCRD(") && strings.HasSuffix(part, ")"): + // LargeCRD(250) + countStr := part[len("LargeCRD(") : len(part)-1] + count, err := strconv.Atoi(countStr) + if err == nil { + opts = append(opts, catalog.WithLargeCRD(count)) + } + case strings.HasPrefix(part, "ClusterRegistry(") && strings.HasSuffix(part, ")"): + // ClusterRegistry(mirrored-registry.operator-controller-e2e.svc.cluster.local:5000) + host := part[len("ClusterRegistry(") : len(part)-1] + opts = append(opts, catalog.WithClusterRegistry(host)) + case strings.HasPrefix(part, "StaticBundleDir(") && strings.HasSuffix(part, ")"): + // StaticBundleDir(testdata/images/bundles/webhook-operator/v0.0.1) + dir := part[len("StaticBundleDir(") : len(part)-1] + absDir := filepath.Join(projectRootDir(), dir) + opts = append(opts, catalog.StaticBundleDir(absDir)) + } + } + return opts +} + // PrometheusMetricsAreReturned validates that each pod's stored metrics response is non-empty and parses as valid Prometheus text format. func PrometheusMetricsAreReturned(ctx context.Context) error { sc := scenarioCtx(ctx) @@ -1449,6 +1722,7 @@ func PrometheusMetricsAreReturned(ctx context.Context) error { // OperatorTargetNamespace asserts that the operator deployment has the expected olm.targetNamespaces annotation. func OperatorTargetNamespace(ctx context.Context, operator, namespace string) error { sc := scenarioCtx(ctx) + operator = substituteScenarioVars(operator, sc) namespace = substituteScenarioVars(namespace, sc) raw, err := k8sClient("get", "deployment", "-n", sc.namespace, operator, "-o", "json") if err != nil { @@ -1465,10 +1739,11 @@ func OperatorTargetNamespace(ctx context.Context, operator, namespace string) er return nil } -// MarkTestOperatorNotReady controls the test-operator's readiness probe by removing or creating the readiness file in its pod. -func MarkTestOperatorNotReady(ctx context.Context, state string) error { +// MarkDeploymentReadiness controls a deployment's readiness probe by removing or creating the readiness file in its pod. +func MarkDeploymentReadiness(ctx context.Context, deploymentName, state string) error { sc := scenarioCtx(ctx) - v, err := k8sClient("get", "deployment", "-n", sc.namespace, "test-operator", "-o", "jsonpath={.spec.selector.matchLabels}") + deploymentName = substituteScenarioVars(deploymentName, sc) + v, err := k8sClient("get", "deployment", "-n", sc.namespace, deploymentName, "-o", "jsonpath={.spec.selector.matchLabels}") if err != nil { return err } @@ -1773,7 +2048,7 @@ func AnnotationsAreAdded(ctx context.Context, resourceName string, table *godog. sc := scenarioCtx(ctx) resourceName = substituteScenarioVars(resourceName, sc) - pairs, err := parseKeyValueTable(table) + pairs, err := parseKeyValueTable(table, sc) if err != nil { return fmt.Errorf("invalid annotations table: %w", err) } @@ -1801,7 +2076,7 @@ func LabelsAreAdded(ctx context.Context, resourceName string, table *godog.Table sc := scenarioCtx(ctx) resourceName = substituteScenarioVars(resourceName, sc) - pairs, err := parseKeyValueTable(table) + pairs, err := parseKeyValueTable(table, sc) if err != nil { return fmt.Errorf("invalid labels table: %w", err) } @@ -1829,7 +2104,7 @@ func ResourceHasAnnotations(ctx context.Context, resourceName string, table *god sc := scenarioCtx(ctx) resourceName = substituteScenarioVars(resourceName, sc) - expected, err := parseKeyValueTable(table) + expected, err := parseKeyValueTable(table, sc) if err != nil { return fmt.Errorf("invalid annotations table: %w", err) } @@ -1878,7 +2153,7 @@ func ResourceHasLabels(ctx context.Context, resourceName string, table *godog.Ta sc := scenarioCtx(ctx) resourceName = substituteScenarioVars(resourceName, sc) - expected, err := parseKeyValueTable(table) + expected, err := parseKeyValueTable(table, sc) if err != nil { return fmt.Errorf("invalid labels table: %w", err) } @@ -1926,7 +2201,8 @@ func nestedString(obj map[string]interface{}, keys ...string) (string, bool) { // parseKeyValueTable extracts key-value pairs from a godog data table. // The table must have a header row with "key" and "value" columns. -func parseKeyValueTable(table *godog.Table) (map[string]string, error) { +// If sc is non-nil, variable substitution is applied to both keys and values. +func parseKeyValueTable(table *godog.Table, sc *scenarioContext) (map[string]string, error) { if len(table.Rows) < 2 { return nil, fmt.Errorf("table must have a header row and at least one data row") } @@ -1955,7 +2231,13 @@ func parseKeyValueTable(table *godog.Table) (map[string]string, error) { if len(row.Cells) <= maxIdx { return nil, fmt.Errorf("table row %d has %d cells, expected at least %d", rowIdx+2, len(row.Cells), maxIdx+1) } - result[row.Cells[keyIdx].Value] = row.Cells[valueIdx].Value + key := row.Cells[keyIdx].Value + value := row.Cells[valueIdx].Value + if sc != nil { + key = substituteScenarioVars(key, sc) + value = substituteScenarioVars(value, sc) + } + result[key] = value } return result, nil } diff --git a/test/e2e/steps/testdata/extra-catalog-template.yaml b/test/e2e/steps/testdata/extra-catalog-template.yaml deleted file mode 100644 index a43d9b3246..0000000000 --- a/test/e2e/steps/testdata/extra-catalog-template.yaml +++ /dev/null @@ -1,11 +0,0 @@ -apiVersion: olm.operatorframework.io/v1 -kind: ClusterCatalog -metadata: - name: extra-catalog -spec: - priority: 0 - source: - type: Image - image: - pollIntervalMinutes: 1 - ref: ${CATALOG_IMG} diff --git a/test/e2e/steps/testdata/test-catalog-template.yaml b/test/e2e/steps/testdata/test-catalog-template.yaml deleted file mode 100644 index 7e46872f38..0000000000 --- a/test/e2e/steps/testdata/test-catalog-template.yaml +++ /dev/null @@ -1,11 +0,0 @@ -apiVersion: olm.operatorframework.io/v1 -kind: ClusterCatalog -metadata: - name: test-catalog -spec: - priority: 0 - source: - type: Image - image: - pollIntervalMinutes: 1 - ref: ${CATALOG_IMG} diff --git a/test/e2e/steps/upgrade_steps.go b/test/e2e/steps/upgrade_steps.go index 3868479a84..0c82437a2a 100644 --- a/test/e2e/steps/upgrade_steps.go +++ b/test/e2e/steps/upgrade_steps.go @@ -144,26 +144,15 @@ func reconcileEndingCheck(leaderPod, resourceName string) func() bool { } } -// ResourceTypeIsReconciled waits for the component's deployment to be ready and -// then verifies that the scenario's resource of the given type has been reconciled +// ClusterExtensionIsReconciled waits for the ClusterExtension to be reconciled // by checking the leader pod's logs for a "reconcile ending" entry. -func ResourceTypeIsReconciled(ctx context.Context, resourceType string) error { +func ClusterExtensionIsReconciled(ctx context.Context) error { sc := scenarioCtx(ctx) - component, ok := resourceTypeToComponent[resourceType] - if !ok { - return fmt.Errorf("unknown resource type: %s", resourceType) - } - - var resourceName string - switch resourceType { - case "ClusterCatalog": - resourceName = sc.clusterCatalogName - case "ClusterExtension": - resourceName = sc.clusterExtensionName - } + component := "operator-controller" + resourceName := sc.clusterExtensionName if resourceName == "" { - return fmt.Errorf("no %s found in scenario context", resourceType) + return fmt.Errorf("no ClusterExtension found in scenario context") } if err := ComponentIsReadyToReconcile(ctx, component); err != nil { @@ -172,13 +161,6 @@ func ResourceTypeIsReconciled(ctx context.Context, resourceType string) error { leaderPod := sc.leaderPods[component] waitFor(ctx, reconcileEndingCheck(leaderPod, resourceName)) - - // For ClusterCatalog, also verify that lastUnpacked is after the leader pod's creation. - // This mitigates flakiness caused by https://github.com/operator-framework/operator-controller/issues/1626 - if resourceType == "ClusterCatalog" { - waitFor(ctx, clusterCatalogUnpackedAfterPodCreation(resourceName, leaderPod)) - } - return nil } @@ -254,11 +236,38 @@ func allResourcesAreReconciled(ctx context.Context, resourceType string) error { return nil } -// ClusterCatalogReportsCondition waits for the ClusterCatalog to have the specified condition type, status, and reason. -func ClusterCatalogReportsCondition(ctx context.Context, conditionType, conditionStatus, conditionReason string) error { +// ScenarioCatalogIsReconciled waits for a named per-scenario ClusterCatalog to be reconciled by checking leader pod logs. +func ScenarioCatalogIsReconciled(ctx context.Context, catalogUserName string) error { + sc := scenarioCtx(ctx) + catalogName, ok := sc.catalogs[catalogUserName] + if !ok { + return fmt.Errorf("no catalog %q has been created for this scenario", catalogUserName) + } + + component := "catalogd" + if err := ComponentIsReadyToReconcile(ctx, component); err != nil { + return err + } + + leaderPod, ok := sc.leaderPods[component] + if !ok { + return fmt.Errorf("leader pod not found for component %s", component) + } + + waitFor(ctx, reconcileEndingCheck(leaderPod, catalogName)) + + // Also verify that lastUnpacked is after the leader pod's creation. + // This mitigates flakiness caused by https://github.com/operator-framework/operator-controller/issues/1626 + waitFor(ctx, clusterCatalogUnpackedAfterPodCreation(catalogName, leaderPod)) + return nil +} + +// ScenarioCatalogReportsCondition waits for a named per-scenario ClusterCatalog to have the specified condition. +func ScenarioCatalogReportsCondition(ctx context.Context, catalogUserName, conditionType, conditionStatus, conditionReason string) error { sc := scenarioCtx(ctx) - if sc.clusterCatalogName == "" { - return fmt.Errorf("cluster catalog name not set; run 'ClusterCatalog serves bundles' first") + catalogName, ok := sc.catalogs[catalogUserName] + if !ok { + return fmt.Errorf("no catalog %q has been created for this scenario", catalogUserName) } - return waitForCondition(ctx, "clustercatalog", sc.clusterCatalogName, conditionType, conditionStatus, &conditionReason, nil) + return waitForCondition(ctx, "clustercatalog", catalogName, conditionType, conditionStatus, &conditionReason, nil) } diff --git a/test/extension-developer-e2e/extension_developer_test.go b/test/extension-developer-e2e/extension_developer_test.go index a71f1f83d6..a790b5252a 100644 --- a/test/extension-developer-e2e/extension_developer_test.go +++ b/test/extension-developer-e2e/extension_developer_test.go @@ -4,9 +4,13 @@ import ( "context" "fmt" "os" + "os/exec" "testing" "time" + "github.com/google/go-containerregistry/pkg/crane" + "github.com/google/go-containerregistry/pkg/name" + "github.com/google/go-containerregistry/pkg/v1/tarball" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" corev1 "k8s.io/api/core/v1" @@ -19,22 +23,105 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client" ocv1 "github.com/operator-framework/operator-controller/api/v1" + testregistry "github.com/operator-framework/operator-controller/test/internal/registry" ) +const ( + catalogTag = "e2e/test-catalog:v1" + regPkgName = "registry-operator" +) + +func TestMain(m *testing.M) { + ctx := context.Background() + cfg := ctrl.GetConfigOrDie() + if err := testregistry.Deploy(ctx, cfg, testregistry.DefaultNamespace, testregistry.DefaultName); err != nil { + panic(fmt.Sprintf("failed to deploy image registry: %v", err)) + } + + // Port-forward lives for the duration of the test process; + // the stop function is not needed because the goroutine is + // cleaned up on process exit. + localAddr, _, err := testregistry.PortForward(ctx, cfg, testregistry.DefaultNamespace, testregistry.DefaultName) + if err != nil { + panic(fmt.Sprintf("failed to port-forward to registry: %v", err)) + } + + clusterRegistryHost := os.Getenv("CLUSTER_REGISTRY_HOST") + if clusterRegistryHost == "" { + panic("CLUSTER_REGISTRY_HOST environment variable must be set") + } + + // Set env vars for setup.sh — single source of truth + os.Setenv("CATALOG_TAG", catalogTag) + os.Setenv("REG_PKG_NAME", regPkgName) + + cmd := exec.Command("./setup.sh") //nolint:gosec // test-only setup script + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + if err := cmd.Run(); err != nil { + panic(fmt.Sprintf("failed to run setup.sh: %v", err)) + } + + // Push images via crane through the port-forward. + // setup.sh tags images with CLUSTER_REGISTRY_HOST. We export them + // from the container runtime via "save" and push through the + // port-forward with crane. + containerRuntime := os.Getenv("CONTAINER_RUNTIME") + bundlePath := "bundles/registry-v1/registry-bundle:v0.0.1" + for _, path := range []string{bundlePath, catalogTag} { + srcRef := fmt.Sprintf("%s/%s", clusterRegistryHost, path) + pushRef := fmt.Sprintf("%s/%s", localAddr, path) + if err := saveAndPush(containerRuntime, srcRef, pushRef); err != nil { + panic(fmt.Sprintf("failed to push image %s: %v", pushRef, err)) + } + } + + os.Exit(m.Run()) +} + +// saveAndPush exports an image from the container runtime to a temp file, +// then loads and pushes it to the registry via crane. +func saveAndPush(containerRuntime, srcRef, pushRef string) error { + f, err := os.CreateTemp("", "image-*.tar") + if err != nil { + return fmt.Errorf("failed to create temp file: %w", err) + } + defer os.Remove(f.Name()) + defer f.Close() + + saveCmd := exec.Command(containerRuntime, "save", srcRef) //nolint:gosec + saveCmd.Stdout = f + if err := saveCmd.Run(); err != nil { + return fmt.Errorf("failed to save image %s: %w", srcRef, err) + } + if err := f.Close(); err != nil { + return fmt.Errorf("failed to close temp file: %w", err) + } + + tag, err := name.NewTag(srcRef) + if err != nil { + return fmt.Errorf("failed to parse tag %s: %w", srcRef, err) + } + img, err := tarball.ImageFromPath(f.Name(), &tag) + if err != nil { + return fmt.Errorf("failed to load image %s from tarball: %w", srcRef, err) + } + if err := crane.Push(img, pushRef, crane.Insecure); err != nil { + return fmt.Errorf("failed to push image %s: %w", pushRef, err) + } + return nil +} + func TestExtensionDeveloper(t *testing.T) { t.Parallel() cfg := ctrl.GetConfigOrDie() scheme := runtime.NewScheme() - require.NoError(t, ocv1.AddToScheme(scheme)) require.NoError(t, ocv1.AddToScheme(scheme)) require.NoError(t, corev1.AddToScheme(scheme)) require.NoError(t, rbacv1.AddToScheme(scheme)) - require.NotEmpty(t, os.Getenv("CATALOG_IMG"), "environment variable CATALOG_IMG must be set") - require.NotEmpty(t, os.Getenv("REG_PKG_NAME"), "environment variable REG_PKG_NAME must be set") - c, err := client.New(cfg, client.Options{Scheme: scheme}) require.NoError(t, err) @@ -48,7 +135,7 @@ func TestExtensionDeveloper(t *testing.T) { Source: ocv1.CatalogSource{ Type: ocv1.SourceTypeImage, Image: &ocv1.ImageSource{ - Ref: os.Getenv("CATALOG_IMG"), + Ref: os.Getenv("CLUSTER_REGISTRY_HOST") + "/" + catalogTag, }, }, }, @@ -73,7 +160,7 @@ func TestExtensionDeveloper(t *testing.T) { Source: ocv1.SourceConfig{ SourceType: "Catalog", Catalog: &ocv1.CatalogFilter{ - PackageName: os.Getenv("REG_PKG_NAME"), + PackageName: regPkgName, }, }, Namespace: installNamespace, diff --git a/test/extension-developer-e2e/setup.sh b/test/extension-developer-e2e/setup.sh index 293341b33b..9293ef420c 100755 --- a/test/extension-developer-e2e/setup.sh +++ b/test/extension-developer-e2e/setup.sh @@ -8,38 +8,30 @@ help="setup.sh is used to build extensions using the operator-sdk and build the image + bundle image, and create a FBC image for the following bundle formats: - registry+v1 -This script will ensure that all images built are loaded onto -a KinD cluster with the name specified in the arguments. +Images are built and tagged locally; pushing to the registry is +handled by the Go test code via crane + port-forward. The following environment variables are required for configuring this script: -- \$E2E_TEST_CATALOG_V1 - the tag for the catalog image that contains the registry+v1 bundle. -- \$REG_PKG_NAME - the name of the package for the extension that uses the registry+v1 bundle format. -setup.sh also takes 5 arguments. +- \$OPERATOR_SDK - path to the operator-sdk binary. +- \$CONTAINER_RUNTIME - container runtime to use (e.g. docker, podman). +- \$CLUSTER_REGISTRY_HOST - registry address accessible from inside the cluster. +- \$CATALOG_TAG - OCI tag for the catalog image (e.g. e2e/test-catalog:v1). +- \$REG_PKG_NAME - the name of the package for the extension. Usage: - setup.sh [OPERATOR_SDK] [CONTAINER_RUNTIME] [KUSTOMIZE] [LOCAL_REGISTRY_HOST] [CLUSTER_REGISTRY_HOST] + setup.sh " ######################################## # Input validation ######################################## -if [[ "$#" -ne 5 ]]; then - echo "Illegal number of arguments passed" - echo "${help}" - exit 1 -fi - -if [[ -z "${E2E_TEST_CATALOG_V1}" ]]; then - echo "\$E2E_TEST_CATALOG_V1 is required to be set" - echo "${help}" - exit 1 -fi - -if [[ -z "${REG_PKG_NAME}" ]]; then - echo "\$REG_PKG_NAME is required to be set" - echo "${help}" - exit 1 -fi +for var in OPERATOR_SDK CONTAINER_RUNTIME CLUSTER_REGISTRY_HOST CATALOG_TAG REG_PKG_NAME; do + if [[ -z "${!var:-}" ]]; then + echo "\$$var is required to be set" + echo "${help}" + exit 1 + fi +done ######################################## # Setup temp dir and local variables @@ -54,28 +46,15 @@ DOMAIN=oc-opdev-e2e.operatorframework.io REG_DIR="${TMP_ROOT}/registry" mkdir -p "${REG_DIR}" -operator_sdk=$1 -container_tool=$2 -kustomize=$3 -# The path we use to push the image from _outside_ the cluster -local_registry_host=$4 -# The path we use _inside_ the cluster -cluster_registry_host=$5 - -tls_flag="" -if [[ "$container_tool" == "podman" ]]; then - echo "Using podman container runtime; adding tls disable flag" - tls_flag="--tls-verify=false" -fi - -catalog_push_tag="${local_registry_host}/${E2E_TEST_CATALOG_V1}" +operator_sdk="${OPERATOR_SDK}" +container_tool="${CONTAINER_RUNTIME}" +cluster_registry_host="${CLUSTER_REGISTRY_HOST}" + +catalog_tag="${cluster_registry_host}/${CATALOG_TAG}" reg_pkg_name="${REG_PKG_NAME}" reg_img="${DOMAIN}/registry:v0.0.1" -reg_bundle_path="bundles/registry-v1/registry-bundle:v0.0.1" - -reg_bundle_img="${cluster_registry_host}/${reg_bundle_path}" -reg_bundle_push_tag="${local_registry_host}/${reg_bundle_path}" +reg_bundle_img="${cluster_registry_host}/bundles/registry-v1/registry-bundle:v0.0.1" ######################################## # Create the registry+v1 based extension @@ -102,13 +81,18 @@ reg_bundle_push_tag="${local_registry_host}/${reg_bundle_path}" --resource --controller && \ export OPERATOR_SDK="${operator_sdk}" && \ make generate manifests && \ + sed -i -e 's/$(CONTAINER_TOOL) build/$(CONTAINER_TOOL) build --provenance=false/' Makefile && \ make docker-build IMG="${reg_img}" && \ sed -i -e 's/$(OPERATOR_SDK) generate kustomize manifests -q/$(OPERATOR_SDK) generate kustomize manifests -q --interactive=false/g' Makefile && \ make bundle IMG="${reg_img}" VERSION=0.0.1 && \ - make bundle-build BUNDLE_IMG="${reg_bundle_push_tag}" - ${container_tool} push ${reg_bundle_push_tag} ${tls_flag} + make bundle-build BUNDLE_IMG="${reg_bundle_img}" ) +# Push is handled by the Go test via crane + port-forward, +# because docker push goes through the Docker daemon which +# may be in a different network context (e.g. colima VM). + + ############################### # Create the FBC that contains # the registry+v1 extensions @@ -153,5 +137,6 @@ cat < "${TMP_ROOT}"/catalog/index.yaml } EOF -${container_tool} build -f "${TMP_ROOT}/catalog.Dockerfile" -t "${catalog_push_tag}" "${TMP_ROOT}/" -${container_tool} push ${catalog_push_tag} ${tls_flag} +${container_tool} build --provenance=false -f "${TMP_ROOT}/catalog.Dockerfile" -t "${catalog_tag}" "${TMP_ROOT}/" + +# Push is handled by the Go test via crane + port-forward. diff --git a/test/helpers/feature_gates.go b/test/helpers/feature_gates.go deleted file mode 100644 index bd8362448f..0000000000 --- a/test/helpers/feature_gates.go +++ /dev/null @@ -1,108 +0,0 @@ -// Package utils provides helper functions for e2e tests, including -// feature gate detection and validation utilities. -package utils - -import ( - "strings" - "sync" - "testing" - - "github.com/stretchr/testify/require" - appsv1 "k8s.io/api/apps/v1" - "k8s.io/component-base/featuregate" - "sigs.k8s.io/controller-runtime/pkg/client" - - catdfeatures "github.com/operator-framework/operator-controller/internal/catalogd/features" - opconfeatures "github.com/operator-framework/operator-controller/internal/operator-controller/features" -) - -var ( - featureGateStatus map[string]bool - featureGateStatusOnce sync.Once -) - -const ( - fgPrefix = "--feature-gates=" -) - -// SkipIfFeatureGateDisabled skips the test if the specified feature gate is disabled. -// It queries the OLM deployments to detect feature gate settings and falls back to -// programmatic defaults if the feature gate is not explicitly configured. -func SkipIfFeatureGateDisabled(t *testing.T, fg string) { - if !isFeatureGateEnabled(t, fg) { - t.Skipf("Feature-gate %q disabled", fg) - } -} - -func isFeatureGateEnabled(t *testing.T, fg string) bool { - gatherFeatureGates(t) - enabled, ok := featureGateStatus[fg] - if ok { - return enabled - } - - // Not found (i.e. not explicitly set), so we need to find the programmed default. - // Because feature-gates are organized by catd/opcon, we need to check each individually. - // To avoid a panic, we need to check if it's a known gate first. - mfgs := []featuregate.MutableFeatureGate{ - catdfeatures.CatalogdFeatureGate, - opconfeatures.OperatorControllerFeatureGate, - } - f := featuregate.Feature(fg) - for _, mfg := range mfgs { - known := mfg.GetAll() - if _, ok := known[f]; ok { - e := mfg.Enabled(f) - t.Logf("Feature-gate %q not found in arguments, defaulting to %v", fg, e) - return e - } - } - - t.Fatalf("Unknown feature-gate: %q", fg) - return false // unreachable, but required for compilation -} - -func processFeatureGate(t *testing.T, featureGateValue string) { - fgvs := strings.Split(featureGateValue, ",") - for _, fg := range fgvs { - v := strings.Split(fg, "=") - require.Len(t, v, 2, "invalid feature-gate format: %q (expected name=value)", fg) - switch v[1] { - case "true": - featureGateStatus[v[0]] = true - t.Logf("Feature-gate %q enabled", v[0]) - case "false": - featureGateStatus[v[0]] = false - t.Logf("Feature-gate %q disabled", v[0]) - default: - t.Fatalf("invalid feature-gate value: %q (expected true or false)", fg) - } - } -} - -func gatherFeatureGatesFromDeployment(t *testing.T, dep *appsv1.Deployment) { - for _, con := range dep.Spec.Template.Spec.Containers { - for _, arg := range con.Args { - if strings.HasPrefix(arg, fgPrefix) { - processFeatureGate(t, strings.TrimPrefix(arg, fgPrefix)) - } - } - } -} - -func gatherFeatureGates(t *testing.T) { - featureGateStatusOnce.Do(func() { - featureGateStatus = make(map[string]bool) - - depList := &appsv1.DeploymentList{} - err := c.List(t.Context(), depList, client.MatchingLabels{ - "app.kubernetes.io/part-of": "olm", - }) - require.NoError(t, err) - require.Len(t, depList.Items, 2) - - for _, d := range depList.Items { - gatherFeatureGatesFromDeployment(t, &d) - } - }) -} diff --git a/test/helpers/helpers.go b/test/helpers/helpers.go deleted file mode 100644 index af142c6e34..0000000000 --- a/test/helpers/helpers.go +++ /dev/null @@ -1,391 +0,0 @@ -package utils - -import ( - "context" - "fmt" - "os" - "testing" - "time" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" - corev1 "k8s.io/api/core/v1" - rbacv1 "k8s.io/api/rbac/v1" - apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" - "k8s.io/apimachinery/pkg/api/errors" - apimeta "k8s.io/apimachinery/pkg/api/meta" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/labels" - "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/util/rand" - utilruntime "k8s.io/apimachinery/pkg/util/runtime" - "k8s.io/client-go/rest" - "k8s.io/utils/ptr" - ctrl "sigs.k8s.io/controller-runtime" - "sigs.k8s.io/controller-runtime/pkg/client" - - ocv1 "github.com/operator-framework/operator-controller/api/v1" - "github.com/operator-framework/operator-controller/internal/operator-controller/scheme" -) - -var ( - cfg *rest.Config - c client.Client -) - -const ( - pollDuration = time.Minute - pollInterval = time.Second - testCatalogName = "test-catalog" - testCatalogRefEnvVar = "CATALOG_IMG" -) - -func CreateNamespace(ctx context.Context, name string) (*corev1.Namespace, error) { - ns := &corev1.Namespace{ - ObjectMeta: metav1.ObjectMeta{ - Name: name, - }, - } - err := c.Create(ctx, ns) - if err != nil { - return nil, err - } - return ns, nil -} - -func CreateServiceAccount(ctx context.Context, name types.NamespacedName, clusterExtensionName string) (*corev1.ServiceAccount, error) { - sa := &corev1.ServiceAccount{ - ObjectMeta: metav1.ObjectMeta{ - Name: name.Name, - Namespace: name.Namespace, - }, - } - err := c.Create(ctx, sa) - if err != nil { - return nil, err - } - - return sa, CreateClusterRoleAndBindingForSA(ctx, name.Name, sa, clusterExtensionName) -} - -func CreateClusterRoleAndBindingForSA(ctx context.Context, name string, sa *corev1.ServiceAccount, clusterExtensionName string) error { - cr := &rbacv1.ClusterRole{ - ObjectMeta: metav1.ObjectMeta{ - Name: name, - }, - Rules: []rbacv1.PolicyRule{ - { - APIGroups: []string{ - "olm.operatorframework.io", - }, - Resources: []string{ - "clusterextensions/finalizers", - }, - Verbs: []string{ - "update", - }, - ResourceNames: []string{clusterExtensionName}, - }, - { - APIGroups: []string{ - "", - }, - Resources: []string{ - "configmaps", - "secrets", // for helm - "services", - "serviceaccounts", - }, - Verbs: []string{ - "create", - "update", - "delete", - "patch", - "get", - "list", - "watch", - }, - }, - { - APIGroups: []string{ - "apiextensions.k8s.io", - }, - Resources: []string{ - "customresourcedefinitions", - }, - Verbs: []string{ - "create", - "update", - "delete", - "patch", - "get", - "list", - "watch", - }, - }, - { - APIGroups: []string{ - "apps", - }, - Resources: []string{ - "deployments", - }, - Verbs: []string{ - "create", - "update", - "delete", - "patch", - "get", - "list", - "watch", - }, - }, - { - APIGroups: []string{ - "rbac.authorization.k8s.io", - }, - Resources: []string{ - "clusterroles", - "roles", - "clusterrolebindings", - "rolebindings", - }, - Verbs: []string{ - "create", - "update", - "delete", - "patch", - "get", - "list", - "watch", - "bind", - "escalate", - }, - }, - { - APIGroups: []string{ - "networking.k8s.io", - }, - Resources: []string{ - "networkpolicies", - }, - Verbs: []string{ - "get", - "list", - "watch", - "create", - "update", - "patch", - "delete", - }, - }, - }, - } - err := c.Create(ctx, cr) - if err != nil { - return err - } - crb := &rbacv1.ClusterRoleBinding{ - ObjectMeta: metav1.ObjectMeta{ - Name: name, - }, - Subjects: []rbacv1.Subject{ - { - Kind: "ServiceAccount", - Name: sa.Name, - Namespace: sa.Namespace, - }, - }, - RoleRef: rbacv1.RoleRef{ - APIGroup: "rbac.authorization.k8s.io", - Kind: "ClusterRole", - Name: name, - }, - } - err = c.Create(ctx, crb) - if err != nil { - return err - } - - return nil -} - -func TestInit(t *testing.T) (*ocv1.ClusterExtension, *ocv1.ClusterCatalog, *corev1.ServiceAccount, *corev1.Namespace) { - ce, cc := TestInitClusterExtensionClusterCatalog(t) - sa, ns := TestInitServiceAccountNamespace(t, ce.Name) - return ce, cc, sa, ns -} - -func TestInitClusterExtensionClusterCatalog(t *testing.T) (*ocv1.ClusterExtension, *ocv1.ClusterCatalog) { - ceName := fmt.Sprintf("clusterextension-%s", rand.String(8)) - catalogName := fmt.Sprintf("test-catalog-%s", rand.String(8)) - - ce := &ocv1.ClusterExtension{ - ObjectMeta: metav1.ObjectMeta{ - Name: ceName, - }, - } - - cc, err := CreateTestCatalog(context.Background(), catalogName, os.Getenv(testCatalogRefEnvVar)) - require.NoError(t, err) - - ValidateCatalogUnpackWithName(t, catalogName) - - return ce, cc -} - -func TestInitServiceAccountNamespace(t *testing.T, clusterExtensionName string) (*corev1.ServiceAccount, *corev1.Namespace) { - var err error - - ns, err := CreateNamespace(context.Background(), clusterExtensionName) - require.NoError(t, err) - - name := types.NamespacedName{ - Name: clusterExtensionName, - Namespace: ns.GetName(), - } - - sa, err := CreateServiceAccount(context.Background(), name, clusterExtensionName) - require.NoError(t, err) - - return sa, ns -} - -// ValidateCatalogUnpack validates that the test catalog with the default name has unpacked successfully. -// Deprecated: Use ValidateCatalogUnpackWithName for tests that use unique catalog names. -func ValidateCatalogUnpack(t *testing.T) { - ValidateCatalogUnpackWithName(t, testCatalogName) -} - -// ValidateCatalogUnpackWithName validates that a catalog with the given name has unpacked successfully. -func ValidateCatalogUnpackWithName(t *testing.T, catalogName string) { - catalog := &ocv1.ClusterCatalog{} - t.Log("Ensuring ClusterCatalog has Status.Condition of Progressing with a status == True and reason == Succeeded") - require.EventuallyWithT(t, func(ct *assert.CollectT) { - err := c.Get(context.Background(), types.NamespacedName{Name: catalogName}, catalog) - require.NoError(ct, err) - cond := apimeta.FindStatusCondition(catalog.Status.Conditions, ocv1.TypeProgressing) - require.NotNil(ct, cond) - require.Equal(ct, metav1.ConditionTrue, cond.Status) - require.Equal(ct, ocv1.ReasonSucceeded, cond.Reason) - }, pollDuration, pollInterval) - - t.Log("Checking that catalog has the expected metadata label") - require.NotNil(t, catalog.Labels) - require.Contains(t, catalog.Labels, "olm.operatorframework.io/metadata.name") - require.Equal(t, catalogName, catalog.Labels["olm.operatorframework.io/metadata.name"]) - - t.Log("Ensuring ClusterCatalog has Status.Condition of Type = Serving with status == True") - require.EventuallyWithT(t, func(ct *assert.CollectT) { - err := c.Get(context.Background(), types.NamespacedName{Name: catalogName}, catalog) - require.NoError(ct, err) - cond := apimeta.FindStatusCondition(catalog.Status.Conditions, ocv1.TypeServing) - require.NotNil(ct, cond) - require.Equal(ct, metav1.ConditionTrue, cond.Status) - require.Equal(ct, ocv1.ReasonAvailable, cond.Reason) - }, pollDuration, pollInterval) -} - -func EnsureNoExtensionResources(t *testing.T, clusterExtensionName string) { - ls := labels.Set{"olm.operatorframework.io/owner-name": clusterExtensionName} - - // CRDs may take an extra long time to be deleted, and may run into the following error: - // Condition=Terminating Status=True Reason=InstanceDeletionFailed Message="could not list instances: storage is (re)initializing" - t.Logf("By waiting for CustomResourceDefinitions of %q to be deleted", clusterExtensionName) - require.EventuallyWithT(t, func(ct *assert.CollectT) { - list := &apiextensionsv1.CustomResourceDefinitionList{} - err := c.List(context.Background(), list, client.MatchingLabelsSelector{Selector: ls.AsSelector()}) - require.NoError(ct, err) - require.Empty(ct, list.Items) - }, 5*pollDuration, pollInterval) - - t.Logf("By waiting for ClusterRoleBindings of %q to be deleted", clusterExtensionName) - require.EventuallyWithT(t, func(ct *assert.CollectT) { - list := &rbacv1.ClusterRoleBindingList{} - err := c.List(context.Background(), list, client.MatchingLabelsSelector{Selector: ls.AsSelector()}) - require.NoError(ct, err) - require.Empty(ct, list.Items) - }, 2*pollDuration, pollInterval) - - t.Logf("By waiting for ClusterRoles of %q to be deleted", clusterExtensionName) - require.EventuallyWithT(t, func(ct *assert.CollectT) { - list := &rbacv1.ClusterRoleList{} - err := c.List(context.Background(), list, client.MatchingLabelsSelector{Selector: ls.AsSelector()}) - require.NoError(ct, err) - require.Empty(ct, list.Items) - }, 2*pollDuration, pollInterval) -} - -func TestCleanup(t *testing.T, cat *ocv1.ClusterCatalog, clusterExtension *ocv1.ClusterExtension, sa *corev1.ServiceAccount, ns *corev1.Namespace) { - if cat != nil { - t.Logf("By deleting ClusterCatalog %q", cat.Name) - require.NoError(t, c.Delete(context.Background(), cat)) - require.Eventually(t, func() bool { - err := c.Get(context.Background(), types.NamespacedName{Name: cat.Name}, &ocv1.ClusterCatalog{}) - return errors.IsNotFound(err) - }, pollDuration, pollInterval) - } - - if clusterExtension != nil { - t.Logf("By deleting ClusterExtension %q", clusterExtension.Name) - require.NoError(t, c.Delete(context.Background(), clusterExtension)) - require.Eventually(t, func() bool { - err := c.Get(context.Background(), types.NamespacedName{Name: clusterExtension.Name}, &ocv1.ClusterExtension{}) - return errors.IsNotFound(err) - }, pollDuration, pollInterval) - EnsureNoExtensionResources(t, clusterExtension.Name) - } - - if sa != nil { - t.Logf("By deleting ServiceAccount %q", sa.Name) - require.NoError(t, c.Delete(context.Background(), sa)) - require.Eventually(t, func() bool { - err := c.Get(context.Background(), types.NamespacedName{Name: sa.Name, Namespace: sa.Namespace}, &corev1.ServiceAccount{}) - return errors.IsNotFound(err) - }, pollDuration, pollInterval) - } - - if ns != nil { - t.Logf("By deleting Namespace %q", ns.Name) - require.NoError(t, c.Delete(context.Background(), ns)) - require.Eventually(t, func() bool { - err := c.Get(context.Background(), types.NamespacedName{Name: ns.Name}, &corev1.Namespace{}) - return errors.IsNotFound(err) - }, pollDuration, pollInterval) - } -} - -// CreateTestCatalog will create a new catalog on the test cluster, provided -// the context, catalog name, and the image reference. It returns the created catalog -// or an error if any errors occurred while creating the catalog. -// Note that catalogd will automatically create the label: -// -// "olm.operatorframework.io/metadata.name": name -func CreateTestCatalog(ctx context.Context, name string, imageRef string) (*ocv1.ClusterCatalog, error) { - catalog := &ocv1.ClusterCatalog{ - ObjectMeta: metav1.ObjectMeta{ - Name: name, - }, - Spec: ocv1.ClusterCatalogSpec{ - Source: ocv1.CatalogSource{ - Type: ocv1.SourceTypeImage, - Image: &ocv1.ImageSource{ - Ref: imageRef, - PollIntervalMinutes: ptr.To(1), - }, - }, - }, - } - - err := c.Create(ctx, catalog) - return catalog, err -} - -func init() { - cfg = ctrl.GetConfigOrDie() - - var err error - utilruntime.Must(apiextensionsv1.AddToScheme(scheme.Scheme)) - c, err = client.New(cfg, client.Options{Scheme: scheme.Scheme}) - utilruntime.Must(err) -} diff --git a/test/internal/catalog/bundle.go b/test/internal/catalog/bundle.go new file mode 100644 index 0000000000..fce966a625 --- /dev/null +++ b/test/internal/catalog/bundle.go @@ -0,0 +1,475 @@ +package catalog + +import ( + "fmt" + "os" + "path/filepath" + "strings" + "testing/fstest" + + appsv1 "k8s.io/api/apps/v1" + corev1 "k8s.io/api/core/v1" + networkingv1 "k8s.io/api/networking/v1" + rbacv1 "k8s.io/api/rbac/v1" + apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/apimachinery/pkg/util/intstr" + "k8s.io/utils/ptr" + + "github.com/operator-framework/api/pkg/operators/v1alpha1" + + bundlecsv "github.com/operator-framework/operator-controller/internal/testing/bundle/csv" + bundlefs "github.com/operator-framework/operator-controller/internal/testing/bundle/fs" +) + +// BundleOption configures what manifests a bundle contains. +type BundleOption func(*bundleConfig) + +type bundleProperty struct { + propertyType string + value string +} + +type bundleConfig struct { + hasCRD bool + hasDeployment bool + hasConfigMap bool + badContainerImage bool + properties []bundleProperty + installModes []v1alpha1.InstallModeType // if nil, defaults to AllNamespaces + SingleNamespace + largeCRDFieldCount int // if > 0, generate a CRD with this many fields + staticBundleDir string // if set, read bundle from this directory (no parameterization) + clusterRegistryOverride string // if set, use this host in the FBC image ref instead of the default +} + +// bundleSpec is the resolved bundle: version + file map ready for crane.Image(). +type bundleSpec struct { + version string + files map[string][]byte + clusterRegistryOverride string // if set, use this host in the FBC image ref +} + +// WithCRD includes a CRD in the bundle. +func WithCRD() BundleOption { + return func(c *bundleConfig) { c.hasCRD = true } +} + +// WithDeployment includes a deployment (with CSV, script ConfigMap, and NetworkPolicy) in the bundle. +func WithDeployment() BundleOption { + return func(c *bundleConfig) { c.hasDeployment = true } +} + +// WithConfigMap includes an additional test ConfigMap in the bundle. +func WithConfigMap() BundleOption { + return func(c *bundleConfig) { c.hasConfigMap = true } +} + +// WithInstallMode sets the supported install modes for the bundle's CSV. +// If not called, defaults to AllNamespaces + SingleNamespace. +// Mode names: AllNamespaces, SingleNamespace, OwnNamespace, MultiNamespace. +func WithInstallMode(modes ...v1alpha1.InstallModeType) BundleOption { + return func(c *bundleConfig) { + c.installModes = append(c.installModes, modes...) + } +} + +// WithLargeCRD includes a CRD with many fields to test large bundle handling. +func WithLargeCRD(fieldCount int) BundleOption { + return func(c *bundleConfig) { + c.hasCRD = true + c.largeCRDFieldCount = fieldCount + } +} + +// WithClusterRegistry overrides the cluster registry hostname used in the FBC image +// reference for this bundle. The bundle is still pushed to the main local registry, +// but the FBC entry tells the cluster to pull from the specified hostname. +// This is used for testing registry mirroring via registries.conf. +func WithClusterRegistry(host string) BundleOption { + return func(c *bundleConfig) { + c.clusterRegistryOverride = host + } +} + +// StaticBundleDir reads pre-built bundle manifests from the given directory. +// The bundle content is NOT parameterized — resource names remain as-is. +// Use this for bundles with real operator binaries that can't have their +// CRD names changed (e.g. webhook-operator). +func StaticBundleDir(dir string) BundleOption { + return func(c *bundleConfig) { + c.staticBundleDir = dir + } +} + +// WithBundleProperty adds a property to the bundle's metadata/properties.yaml. +func WithBundleProperty(propertyType, value string) BundleOption { + return func(c *bundleConfig) { + c.properties = append(c.properties, bundleProperty{propertyType: propertyType, value: value}) + } +} + +// BadImage produces a bundle with CRD and deployment but uses "wrong/image" as +// the container image, causing ImagePullBackOff at runtime. +func BadImage() BundleOption { + return func(c *bundleConfig) { + c.hasCRD = true + c.hasDeployment = true + c.badContainerImage = true + } +} + +// buildBundle generates the manifest files for a single bundle using the existing +// CSV builder and bundle FS builder. All resource names embed scenarioID for uniqueness. +func buildBundle(scenarioID, packageName, version string, opts []BundleOption) (bundleSpec, error) { + cfg := &bundleConfig{} + for _, o := range opts { + o(cfg) + } + + // Static bundle: read files from disk without parameterization + if cfg.staticBundleDir != "" { + files, err := readBundleDir(cfg.staticBundleDir) + if err != nil { + return bundleSpec{}, fmt.Errorf("failed to read static bundle dir %s: %w", cfg.staticBundleDir, err) + } + return bundleSpec{ + version: version, + files: files, + clusterRegistryOverride: cfg.clusterRegistryOverride, + }, nil + } + + crdGroup := fmt.Sprintf("e2e-%s.e2e.operatorframework.io", scenarioID) + crdPlural := fmt.Sprintf("e2e-%stests", scenarioID) + crdKind := "E2ETest" + crdName := fmt.Sprintf("%s.%s", crdPlural, crdGroup) + deploymentName := fmt.Sprintf("test-operator-%s", scenarioID) + saName := fmt.Sprintf("bundle-manager-%s", scenarioID) + scriptCMName := fmt.Sprintf("httpd-script-%s", scenarioID) + + containerImage := "busybox:1.36" + if cfg.badContainerImage { + containerImage = "wrong/image" + } + + // Build the CSV using the existing CSV builder + var installModes []v1alpha1.InstallModeType + if len(cfg.installModes) == 0 { + installModes = []v1alpha1.InstallModeType{v1alpha1.InstallModeTypeAllNamespaces, v1alpha1.InstallModeTypeSingleNamespace} + } else { + installModes = append(installModes, cfg.installModes...) + } + csvBuilder := bundlecsv.Builder(). + WithName(fmt.Sprintf("%s.v%s", packageName, version)). + WithInstallModeSupportFor(installModes...) + + if cfg.hasCRD { + csvBuilder = csvBuilder.WithOwnedCRDs(v1alpha1.CRDDescription{ + Name: crdName, + Kind: crdKind, + Version: "v1", + DisplayName: crdKind, + Description: "E2E Test Resource", + }) + } + + if cfg.hasDeployment { + csvBuilder = csvBuilder. + WithStrategyDeploymentSpecs(buildDeploymentSpec( + deploymentName, scenarioID, version, saName, scriptCMName, containerImage, + )). + WithPermissions(v1alpha1.StrategyDeploymentPermissions{ + ServiceAccountName: saName, + Rules: []rbacv1.PolicyRule{ + { + APIGroups: []string{""}, + Resources: []string{"configmaps", "serviceaccounts"}, + Verbs: []string{"get", "list", "watch", "create", "update", "patch", "delete"}, + }, + { + APIGroups: []string{"networking.k8s.io"}, + Resources: []string{"networkpolicies"}, + Verbs: []string{"get", "list", "create", "update", "delete"}, + }, + { + APIGroups: []string{"coordination.k8s.io"}, + Resources: []string{"leases"}, + Verbs: []string{"get", "list", "watch", "create", "update", "patch", "delete"}, + }, + { + APIGroups: []string{""}, + Resources: []string{"events"}, + Verbs: []string{"create", "patch"}, + }, + }, + }). + WithClusterPermissions(v1alpha1.StrategyDeploymentPermissions{ + ServiceAccountName: saName, + Rules: []rbacv1.PolicyRule{ + { + APIGroups: []string{"authentication.k8s.io"}, + Resources: []string{"tokenreviews"}, + Verbs: []string{"create"}, + }, + { + APIGroups: []string{"authorization.k8s.io"}, + Resources: []string{"subjectaccessreviews"}, + Verbs: []string{"create"}, + }, + }, + }) + } + + // Build the bundle FS using the existing FS builder + fsBuilder := bundlefs.Builder(). + WithPackageName(packageName). + WithCSV(csvBuilder.Build()) + + // Add script ConfigMap for the deployment + if cfg.hasDeployment { + fsBuilder = fsBuilder. + WithBundleResource("script-configmap.yaml", &corev1.ConfigMap{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "v1", + Kind: "ConfigMap", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: scriptCMName, + }, + Data: map[string]string{ + "httpd.sh": "#!/bin/sh\necho true > /var/www/started\necho true > /var/www/ready\necho true > /var/www/live\nexec httpd -f -h /var/www -p 80\n", + }, + }). + WithBundleResource("networkpolicy.yaml", &networkingv1.NetworkPolicy{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "networking.k8s.io/v1", + Kind: "NetworkPolicy", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: fmt.Sprintf("%s-network-policy", deploymentName), + }, + Spec: networkingv1.NetworkPolicySpec{ + PodSelector: metav1.LabelSelector{}, + PolicyTypes: []networkingv1.PolicyType{networkingv1.PolicyTypeIngress}, + }, + }) + } + + // Add test ConfigMap if requested + if cfg.hasConfigMap { + testCMName := fmt.Sprintf("test-configmap-%s", scenarioID) + fsBuilder = fsBuilder.WithBundleResource("bundle-configmap.yaml", &corev1.ConfigMap{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "v1", + Kind: "ConfigMap", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: testCMName, + }, + Data: map[string]string{ + "version": version, + "name": testCMName, + }, + }) + } + + // Add CRD as a bundle resource + if cfg.hasCRD { + fsBuilder = fsBuilder.WithBundleResource("crd.yaml", buildCRD(crdName, crdGroup, crdKind, crdPlural, scenarioID, cfg.largeCRDFieldCount)) + } + + // Add bundle properties + for _, p := range cfg.properties { + fsBuilder = fsBuilder.WithBundleProperty(p.propertyType, p.value) + } + + bundleFS := fsBuilder.Build() + return bundleSpec{ + version: version, + files: mapFSToFileMap(bundleFS), + clusterRegistryOverride: cfg.clusterRegistryOverride, + }, nil +} + +// buildDeploymentSpec creates the StrategyDeploymentSpec for the CSV. +func buildDeploymentSpec( + deploymentName, scenarioID, version, saName, scriptCMName, containerImage string, +) v1alpha1.StrategyDeploymentSpec { + return v1alpha1.StrategyDeploymentSpec{ + Name: deploymentName, + Label: labels.Set{ + "app.kubernetes.io/name": deploymentName, + "app.kubernetes.io/version": version, + "app.kubernetes.io/component": "controller", + }, + Spec: appsv1.DeploymentSpec{ + Replicas: ptr.To(int32(1)), + Selector: &metav1.LabelSelector{ + MatchLabels: map[string]string{ + "app": scenarioID, + }, + }, + Template: corev1.PodTemplateSpec{ + ObjectMeta: metav1.ObjectMeta{ + Labels: map[string]string{ + "app": scenarioID, + }, + }, + Spec: corev1.PodSpec{ + ServiceAccountName: saName, + TerminationGracePeriodSeconds: ptr.To(int64(0)), + Volumes: []corev1.Volume{ + { + Name: "scripts", + VolumeSource: corev1.VolumeSource{ + ConfigMap: &corev1.ConfigMapVolumeSource{ + LocalObjectReference: corev1.LocalObjectReference{ + Name: scriptCMName, + }, + DefaultMode: ptr.To(int32(0755)), + }, + }, + }, + }, + Containers: []corev1.Container{ + { + Name: "busybox-httpd-container", + Image: containerImage, + Command: []string{"/scripts/httpd.sh"}, + Ports: []corev1.ContainerPort{ + {ContainerPort: 80}, + }, + VolumeMounts: []corev1.VolumeMount{ + { + Name: "scripts", + MountPath: "/scripts", + ReadOnly: true, + }, + }, + StartupProbe: &corev1.Probe{ + ProbeHandler: corev1.ProbeHandler{ + HTTPGet: &corev1.HTTPGetAction{ + Path: "/started", + Port: intstr.FromInt32(80), + }, + }, + FailureThreshold: 30, + PeriodSeconds: 10, + }, + LivenessProbe: &corev1.Probe{ + ProbeHandler: corev1.ProbeHandler{ + HTTPGet: &corev1.HTTPGetAction{ + Path: "/live", + Port: intstr.FromInt32(80), + }, + }, + FailureThreshold: 1, + PeriodSeconds: 2, + }, + ReadinessProbe: &corev1.Probe{ + ProbeHandler: corev1.ProbeHandler{ + HTTPGet: &corev1.HTTPGetAction{ + Path: "/ready", + Port: intstr.FromInt32(80), + }, + }, + InitialDelaySeconds: 1, + PeriodSeconds: 1, + }, + }, + }, + }, + }, + }, + } +} + +// buildCRD creates a CustomResourceDefinition as a client.Object for use with WithBundleResource. +// If largeCRDFieldCount > 0, the CRD spec will contain that many string fields with long descriptions. +func buildCRD(name, group, kind, plural, scenarioID string, largeCRDFieldCount int) *apiextensionsv1.CustomResourceDefinition { + specProperties := map[string]apiextensionsv1.JSONSchemaProps{ + "testField": {Type: "string"}, + } + if largeCRDFieldCount > 0 { + longDescBase := "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. " + longDesc := strings.Repeat(longDescBase, 20) // ~4KB per field, matching the original test fixture + for i := range largeCRDFieldCount { + specProperties[fmt.Sprintf("field%04d", i)] = apiextensionsv1.JSONSchemaProps{ + Type: "string", + Description: longDesc, + } + } + } + + return &apiextensionsv1.CustomResourceDefinition{ + TypeMeta: metav1.TypeMeta{ + APIVersion: "apiextensions.k8s.io/v1", + Kind: "CustomResourceDefinition", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: name, + }, + Spec: apiextensionsv1.CustomResourceDefinitionSpec{ + Group: group, + Names: apiextensionsv1.CustomResourceDefinitionNames{ + Kind: kind, + ListKind: kind + "List", + Plural: plural, + Singular: "e2e-" + scenarioID + "test", + }, + Scope: apiextensionsv1.ClusterScoped, + Versions: []apiextensionsv1.CustomResourceDefinitionVersion{ + { + Name: "v1", + Served: true, + Storage: true, + Schema: &apiextensionsv1.CustomResourceValidation{ + OpenAPIV3Schema: &apiextensionsv1.JSONSchemaProps{ + Type: "object", + Properties: map[string]apiextensionsv1.JSONSchemaProps{ + "spec": { + Type: "object", + Properties: specProperties, + }, + }, + }, + }, + }, + }, + }, + } +} + +// mapFSToFileMap converts an fstest.MapFS to map[string][]byte for use with crane.Image(). +func mapFSToFileMap(mfs fstest.MapFS) map[string][]byte { + files := make(map[string][]byte, len(mfs)) + for path, file := range mfs { + files[path] = file.Data + } + return files +} + +// readBundleDir reads all files from a bundle directory into a map[string][]byte. +func readBundleDir(dir string) (map[string][]byte, error) { + files := make(map[string][]byte) + err := filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error { + if err != nil { + return err + } + if d.IsDir() { + return nil + } + rel, err := filepath.Rel(dir, path) + if err != nil { + return err + } + data, err := os.ReadFile(path) + if err != nil { + return err + } + files[rel] = data + return nil + }) + return files, err +} diff --git a/test/internal/catalog/catalog.go b/test/internal/catalog/catalog.go new file mode 100644 index 0000000000..e4c3f763d5 --- /dev/null +++ b/test/internal/catalog/catalog.go @@ -0,0 +1,235 @@ +package catalog + +import ( + "context" + "fmt" + "strings" + + "github.com/google/go-containerregistry/pkg/crane" + v1 "github.com/google/go-containerregistry/pkg/v1" + "github.com/google/go-containerregistry/pkg/v1/mutate" +) + +// Catalog is a builder for constructing per-scenario FBC catalogs +// with parameterized package names and OCI image references. +type Catalog struct { + name string // user-chosen catalog name (e.g. "test", "extra") + scenarioID string + packages []packageSpec +} + +type packageSpec struct { + name string + bundles []bundleDef + channels []channelDef +} + +type bundleDef struct { + version string + opts []BundleOption +} + +type channelDef struct { + name string + entries []entryDef +} + +type entryDef struct { + version string + replaces string +} + +// PackageOption configures a package within a catalog. +type PackageOption func(*packageSpec) + +// ChannelOption configures a channel entry. +type ChannelOption func(*entryDef) + +// NewCatalog creates a new per-scenario catalog builder. +func NewCatalog(name, scenarioID string, opts ...PackageOption) *Catalog { + c := &Catalog{name: name, scenarioID: scenarioID} + for _, o := range opts { + pkg := packageSpec{} + o(&pkg) + c.packages = append(c.packages, pkg) + } + return c +} + +// WithPackage defines a package in the catalog. +func WithPackage(name string, opts ...PackageOption) PackageOption { + return func(p *packageSpec) { + p.name = name + for _, o := range opts { + o(p) + } + } +} + +// Bundle defines a bundle version with its content options. +func Bundle(version string, opts ...BundleOption) PackageOption { + return func(p *packageSpec) { + p.bundles = append(p.bundles, bundleDef{version: version, opts: opts}) + } +} + +// Channel defines a channel with its entries. +func Channel(name string, entries ...ChannelOption) PackageOption { + return func(p *packageSpec) { + ch := channelDef{name: name} + for _, e := range entries { + entry := entryDef{} + e(&entry) + ch.entries = append(ch.entries, entry) + } + p.channels = append(p.channels, ch) + } +} + +// Entry defines a channel entry for a specific version. +func Entry(version string, opts ...ChannelOption) ChannelOption { + return func(e *entryDef) { + e.version = version + for _, o := range opts { + o(e) + } + } +} + +// Replaces declares the version this entry replaces. +func Replaces(version string) ChannelOption { + return func(e *entryDef) { + e.replaces = version + } +} + +// BuildResult contains the outputs of a successful catalog build. +type BuildResult struct { + // CatalogImageRef is the in-cluster image reference for the ClusterCatalog source. + CatalogImageRef string + // CatalogName is the name to use for the ClusterCatalog resource. + CatalogName string + // PackageNames maps original package names to their scenario-parameterized names. + PackageNames map[string]string +} + +// Build generates all bundle images and the catalog image, pushes them to the registry, +// and returns the image refs needed to create a ClusterCatalog. +// +// tag is the image tag for the catalog image (e.g. "v1", "latest"). +// localRegistry is the registry address accessible from the test process (obtained via port-forward). +// clusterRegistry is the registry address accessible from inside the cluster +// (e.g. docker-registry.operator-controller-e2e.svc.cluster.local:5000). +func (c *Catalog) Build(_ context.Context, tag, localRegistry, clusterRegistry string) (*BuildResult, error) { + packageNames := make(map[string]string) + var fbcDocs []string + + for _, pkg := range c.packages { + paramPkgName := fmt.Sprintf("%s-%s", pkg.name, c.scenarioID) + packageNames[pkg.name] = paramPkgName + + bundleImageRefs := make(map[string]string) // version -> cluster image ref + + // Build and push each bundle image + for _, bd := range pkg.bundles { + spec, err := buildBundle(c.scenarioID, paramPkgName, bd.version, bd.opts) + if err != nil { + return nil, fmt.Errorf("failed to build bundle %s:%s: %w", paramPkgName, bd.version, err) + } + + img, err := crane.Image(spec.files) + if err != nil { + return nil, fmt.Errorf("failed to create bundle image for %s:%s: %w", paramPkgName, bd.version, err) + } + + labels := map[string]string{ + "operators.operatorframework.io.bundle.mediatype.v1": "registry+v1", + "operators.operatorframework.io.bundle.manifests.v1": "manifests/", + "operators.operatorframework.io.bundle.metadata.v1": "metadata/", + "operators.operatorframework.io.bundle.package.v1": paramPkgName, + "operators.operatorframework.io.bundle.channels.v1": "default", + } + img, err = mutate.Config(img, v1.Config{Labels: labels}) + if err != nil { + return nil, fmt.Errorf("failed to set bundle labels for %s:%s: %w", paramPkgName, bd.version, err) + } + + tag := fmt.Sprintf("%s/bundles/%s:v%s", localRegistry, paramPkgName, bd.version) + if err := crane.Push(img, tag, crane.Insecure); err != nil { + return nil, fmt.Errorf("failed to push bundle image %s: %w", tag, err) + } + bundleClusterRegistry := clusterRegistry + if spec.clusterRegistryOverride != "" { + bundleClusterRegistry = spec.clusterRegistryOverride + } + bundleImageRefs[bd.version] = fmt.Sprintf("%s/bundles/%s:v%s", bundleClusterRegistry, paramPkgName, bd.version) + } + + // Generate FBC for this package + defaultChannel := "default" + if len(pkg.channels) > 0 { + defaultChannel = pkg.channels[0].name + } + fbcDocs = append(fbcDocs, fmt.Sprintf(`schema: olm.package +name: %s +defaultChannel: %s`, paramPkgName, defaultChannel)) + + for _, ch := range pkg.channels { + var entries []string + for _, e := range ch.entries { + entry := fmt.Sprintf(" - name: %s.%s", paramPkgName, e.version) + if e.replaces != "" { + entry += fmt.Sprintf("\n replaces: %s.%s", paramPkgName, e.replaces) + } + entries = append(entries, entry) + } + fbcDocs = append(fbcDocs, fmt.Sprintf(`schema: olm.channel +name: %s +package: %s +entries: +%s`, ch.name, paramPkgName, strings.Join(entries, "\n"))) + } + + for _, bd := range pkg.bundles { + imageRef := bundleImageRefs[bd.version] + fbcDocs = append(fbcDocs, fmt.Sprintf(`schema: olm.bundle +name: %s.%s +package: %s +image: %s +properties: + - type: olm.package + value: + packageName: %s + version: %s`, paramPkgName, bd.version, paramPkgName, imageRef, paramPkgName, bd.version)) + } + } + + // Build catalog image + fbcContent := strings.Join(fbcDocs, "\n---\n") + catalogFiles := map[string][]byte{ + "configs/catalog.yaml": []byte(fbcContent), + } + catalogImg, err := crane.Image(catalogFiles) + if err != nil { + return nil, fmt.Errorf("failed to create catalog image: %w", err) + } + catalogImg, err = mutate.Config(catalogImg, v1.Config{ + Labels: map[string]string{ + "operators.operatorframework.io.index.configs.v1": "/configs", + }, + }) + if err != nil { + return nil, fmt.Errorf("failed to set catalog labels: %w", err) + } + + catalogTag := fmt.Sprintf("%s/e2e/%s-catalog-%s:%s", localRegistry, c.name, c.scenarioID, tag) + if err := crane.Push(catalogImg, catalogTag, crane.Insecure); err != nil { + return nil, fmt.Errorf("failed to push catalog image %s: %w", catalogTag, err) + } + + return &BuildResult{ + CatalogImageRef: fmt.Sprintf("%s/e2e/%s-catalog-%s:%s", clusterRegistry, c.name, c.scenarioID, tag), + CatalogName: fmt.Sprintf("%s-catalog-%s", c.name, c.scenarioID), + PackageNames: packageNames, + }, nil +} diff --git a/test/internal/catalog/catalog_test.go b/test/internal/catalog/catalog_test.go new file mode 100644 index 0000000000..70fd345dfa --- /dev/null +++ b/test/internal/catalog/catalog_test.go @@ -0,0 +1,177 @@ +package catalog + +import ( + "strings" + "testing" +) + +func TestBuildBundle_WithCRDAndDeployment(t *testing.T) { + b, err := buildBundle("abc123", "test-abc123", "1.0.0", []BundleOption{WithCRD(), WithDeployment(), WithConfigMap()}) + if err != nil { + t.Fatal(err) + } + + if b.version != "1.0.0" { + t.Errorf("expected version 1.0.0, got %s", b.version) + } + + // Check CRD has parameterized names + crd, ok := b.files["manifests/crd.yaml"] + if !ok { + t.Fatal("expected manifests/crd.yaml") + } + if !strings.Contains(string(crd), "e2e-abc123.e2e.operatorframework.io") { + t.Error("CRD group should contain scenario ID") + } + if !strings.Contains(string(crd), "e2e-abc123tests") { + t.Error("CRD plural should contain scenario ID") + } + + // Check CSV references parameterized deployment name + csv, ok := b.files["manifests/csv.yaml"] + if !ok { + t.Fatal("expected manifests/csv.yaml") + } + if !strings.Contains(string(csv), "test-operator-abc123") { + t.Error("CSV deployment name should contain scenario ID") + } + if !strings.Contains(string(csv), "busybox:1.36") { + t.Error("CSV should use busybox:1.36 as container image") + } + + // Check script ConfigMap + scriptCM, ok := b.files["manifests/script-configmap.yaml"] + if !ok { + t.Fatal("expected manifests/script-configmap.yaml") + } + if !strings.Contains(string(scriptCM), "httpd-script-abc123") { + t.Error("script ConfigMap name should contain scenario ID") + } + + // Check test ConfigMap + cm, ok := b.files["manifests/bundle-configmap.yaml"] + if !ok { + t.Fatal("expected manifests/bundle-configmap.yaml") + } + if !strings.Contains(string(cm), "test-configmap-abc123") { + t.Error("test ConfigMap name should contain scenario ID") + } + + // Check metadata/annotations.yaml exists and contains package name + ann, ok := b.files["metadata/annotations.yaml"] + if !ok { + t.Fatal("expected metadata/annotations.yaml") + } + if !strings.Contains(string(ann), "test-abc123") { + t.Error("annotations should contain package name") + } + + // Check NetworkPolicy + np, ok := b.files["manifests/networkpolicy.yaml"] + if !ok { + t.Fatal("expected manifests/networkpolicy.yaml") + } + if !strings.Contains(string(np), "test-operator-abc123-network-policy") { + t.Error("NetworkPolicy name should contain scenario ID") + } +} + +func TestBuildBundle_BadImage(t *testing.T) { + b, err := buildBundle("bad1", "test-bad1", "1.0.2", []BundleOption{BadImage()}) + if err != nil { + t.Fatal(err) + } + + // BadImage bundles should have CSV with wrong/image + csv, ok := b.files["manifests/csv.yaml"] + if !ok { + t.Fatal("BadImage bundle should have CSV") + } + if !strings.Contains(string(csv), "wrong/image") { + t.Error("BadImage CSV should reference wrong/image") + } + + // BadImage should also set hasCRD=true + if _, ok := b.files["manifests/crd.yaml"]; !ok { + t.Error("BadImage bundle should have CRD") + } +} + +func TestBuildBundle_NoCRD(t *testing.T) { + b, err := buildBundle("nocrd", "test-nocrd", "1.0.0", []BundleOption{WithDeployment()}) + if err != nil { + t.Fatal(err) + } + if _, ok := b.files["manifests/crd.yaml"]; ok { + t.Error("should not have CRD when WithCRD not specified") + } + if _, ok := b.files["manifests/csv.yaml"]; !ok { + t.Error("should have CSV when WithDeployment specified") + } +} + +func TestCatalog_FBCGeneration(t *testing.T) { + cat := NewCatalog("test", "sc1", + WithPackage("test", + Bundle("1.0.0", WithCRD(), WithDeployment(), WithConfigMap()), + Bundle("1.2.0", WithCRD(), WithDeployment()), + Channel("alpha", Entry("1.0.0")), + Channel("beta", Entry("1.0.0"), Entry("1.2.0", Replaces("1.0.0"))), + ), + ) + + if len(cat.packages) != 1 { + t.Fatalf("expected 1 package, got %d", len(cat.packages)) + } + pkg := cat.packages[0] + if pkg.name != "test" { + t.Errorf("expected package name 'test', got %q", pkg.name) + } + if len(pkg.bundles) != 2 { + t.Errorf("expected 2 bundles, got %d", len(pkg.bundles)) + } + if len(pkg.channels) != 2 { + t.Errorf("expected 2 channels, got %d", len(pkg.channels)) + } + + // Verify alpha channel has 1 entry + alpha := pkg.channels[0] + if alpha.name != "alpha" { + t.Errorf("expected channel 'alpha', got %q", alpha.name) + } + if len(alpha.entries) != 1 { + t.Errorf("expected 1 alpha entry, got %d", len(alpha.entries)) + } + + // Verify beta channel has replaces edge + beta := pkg.channels[1] + if len(beta.entries) != 2 { + t.Fatalf("expected 2 beta entries, got %d", len(beta.entries)) + } + if beta.entries[1].replaces != "1.0.0" { + t.Errorf("expected entry 1.2.0 to replace 1.0.0, got %q", beta.entries[1].replaces) + } +} + +func TestCatalog_MultiplePackages(t *testing.T) { + cat := NewCatalog("test", "sc2", + WithPackage("foo", + Bundle("1.0.0", WithCRD(), WithDeployment()), + Channel("stable", Entry("1.0.0")), + ), + WithPackage("bar", + Bundle("2.0.0", WithCRD(), WithDeployment()), + Channel("stable", Entry("2.0.0")), + ), + ) + + if len(cat.packages) != 2 { + t.Fatalf("expected 2 packages, got %d", len(cat.packages)) + } + if cat.packages[0].name != "foo" { + t.Errorf("expected first package 'foo', got %q", cat.packages[0].name) + } + if cat.packages[1].name != "bar" { + t.Errorf("expected second package 'bar', got %q", cat.packages[1].name) + } +} diff --git a/test/internal/registry/registry.go b/test/internal/registry/registry.go new file mode 100644 index 0000000000..e884a1db9c --- /dev/null +++ b/test/internal/registry/registry.go @@ -0,0 +1,229 @@ +// Package registry provides functions to deploy an OCI image registry +// in a Kubernetes cluster for e2e testing. +package registry + +import ( + "context" + "fmt" + "io" + "net/http" + "time" + + certmanagerv1 "github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1" + cmapplyconfig "github.com/cert-manager/cert-manager/pkg/client/applyconfigurations/certmanager/v1" + cmmetaapplyconfig "github.com/cert-manager/cert-manager/pkg/client/applyconfigurations/meta/v1" + appsv1 "k8s.io/api/apps/v1" + corev1 "k8s.io/api/core/v1" + apierrors "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/util/intstr" + "k8s.io/apimachinery/pkg/util/wait" + appsv1ac "k8s.io/client-go/applyconfigurations/apps/v1" + corev1ac "k8s.io/client-go/applyconfigurations/core/v1" + metav1ac "k8s.io/client-go/applyconfigurations/meta/v1" + "k8s.io/client-go/kubernetes" + "k8s.io/client-go/rest" + "k8s.io/client-go/tools/portforward" + "k8s.io/client-go/transport/spdy" + "sigs.k8s.io/controller-runtime/pkg/client" +) + +const ( + DefaultNamespace = "operator-controller-e2e" + DefaultName = "docker-registry" +) + +// Deploy ensures the image registry namespace, TLS certificate, deployment, +// and service exist in the cluster. It is idempotent — if the resources +// already exist, they are updated in place via server-side apply. +func Deploy(ctx context.Context, cfg *rest.Config, namespace, name string) error { + scheme := runtime.NewScheme() + if err := corev1.AddToScheme(scheme); err != nil { + return fmt.Errorf("failed to add core/v1 to scheme: %w", err) + } + if err := appsv1.AddToScheme(scheme); err != nil { + return fmt.Errorf("failed to add apps/v1 to scheme: %w", err) + } + if err := certmanagerv1.AddToScheme(scheme); err != nil { + return fmt.Errorf("failed to add cert-manager/v1 to scheme: %w", err) + } + c, err := client.New(cfg, client.Options{Scheme: scheme}) + if err != nil { + return fmt.Errorf("failed to create client: %w", err) + } + + secretName := fmt.Sprintf("%s-registry", namespace) + fieldOwner := client.FieldOwner("e2e-test") + + // Apply namespace + if err := c.Apply(ctx, corev1ac.Namespace(namespace), fieldOwner, client.ForceOwnership); err != nil { + return fmt.Errorf("failed to apply namespace: %w", err) + } + + // Apply TLS certificate + cert := cmapplyconfig.Certificate(secretName, namespace). + WithSpec(cmapplyconfig.CertificateSpec(). + WithSecretName(secretName). + WithIsCA(true). + WithDNSNames( + fmt.Sprintf("%s.%s.svc", name, namespace), + fmt.Sprintf("%s.%s.svc.cluster.local", name, namespace), + ). + WithPrivateKey(cmapplyconfig.CertificatePrivateKey(). + WithRotationPolicy(certmanagerv1.RotationPolicyAlways). + WithAlgorithm(certmanagerv1.ECDSAKeyAlgorithm). + WithSize(256), + ). + WithIssuerRef(cmmetaapplyconfig.IssuerReference(). + WithName("olmv1-ca"). + WithKind("ClusterIssuer"). + WithGroup("cert-manager.io"), + ), + ) + if err := c.Apply(ctx, cert, fieldOwner, client.ForceOwnership); err != nil { + return fmt.Errorf("failed to apply certificate: %w", err) + } + + // Apply deployment + deploy := appsv1ac.Deployment(name, namespace). + WithLabels(map[string]string{"app": "registry"}). + WithSpec(appsv1ac.DeploymentSpec(). + WithReplicas(1). + WithSelector(metav1ac.LabelSelector(). + WithMatchLabels(map[string]string{"app": "registry"}), + ). + WithTemplate(corev1ac.PodTemplateSpec(). + WithLabels(map[string]string{"app": "registry"}). + WithSpec(corev1ac.PodSpec(). + WithContainers(corev1ac.Container(). + WithName("registry"). + WithImage("registry:3"). + WithImagePullPolicy(corev1.PullIfNotPresent). + WithVolumeMounts(corev1ac.VolumeMount(). + WithName("certs-vol"). + WithMountPath("/certs"), + ). + WithEnv( + corev1ac.EnvVar().WithName("REGISTRY_HTTP_TLS_CERTIFICATE").WithValue("/certs/tls.crt"), + corev1ac.EnvVar().WithName("REGISTRY_HTTP_TLS_KEY").WithValue("/certs/tls.key"), + ), + ). + WithVolumes(corev1ac.Volume(). + WithName("certs-vol"). + WithSecret(corev1ac.SecretVolumeSource(). + WithSecretName(secretName), + ), + ), + ), + ), + ) + if err := c.Apply(ctx, deploy, fieldOwner, client.ForceOwnership); err != nil { + return fmt.Errorf("failed to apply deployment: %w", err) + } + + // Apply service + svc := corev1ac.Service(name, namespace). + WithSpec(corev1ac.ServiceSpec(). + WithSelector(map[string]string{"app": "registry"}). + WithPorts(corev1ac.ServicePort(). + WithName("http"). + WithPort(5000). + WithTargetPort(intstr.FromInt32(5000)), + ), + ) + if err := c.Apply(ctx, svc, fieldOwner, client.ForceOwnership); err != nil { + return fmt.Errorf("failed to apply service: %w", err) + } + + // Wait for the deployment to be available + d := &appsv1.Deployment{} + deployKey := client.ObjectKey{Namespace: namespace, Name: name} + if err := wait.PollUntilContextTimeout(ctx, time.Second, 60*time.Second, true, func(ctx context.Context) (bool, error) { + if err := c.Get(ctx, deployKey, d); err != nil { + if apierrors.IsNotFound(err) { + return false, nil + } + return false, err + } + for _, cond := range d.Status.Conditions { + if cond.Type == appsv1.DeploymentAvailable && cond.Status == corev1.ConditionTrue { + return true, nil + } + } + return false, nil + }); err != nil { + return fmt.Errorf("timed out waiting for registry deployment to become available: %w", err) + } + + return nil +} + +// PortForward establishes a port-forward to the registry pod and returns +// the local address (e.g. "localhost:12345") that can be used to push images. +// The returned stop function should be called to clean up the port-forward. +func PortForward(ctx context.Context, cfg *rest.Config, namespace, name string) (string, func(), error) { + clientset, err := kubernetes.NewForConfig(cfg) + if err != nil { + return "", nil, fmt.Errorf("failed to create kubernetes client: %w", err) + } + + deploy, err := clientset.AppsV1().Deployments(namespace).Get(ctx, name, metav1.GetOptions{}) + if err != nil { + return "", nil, fmt.Errorf("failed to get deployment %s/%s: %w", namespace, name, err) + } + labelSelector := metav1.FormatLabelSelector(deploy.Spec.Selector) + pods, err := clientset.CoreV1().Pods(namespace).List(ctx, metav1.ListOptions{ + LabelSelector: labelSelector, + FieldSelector: "status.phase=Running", + }) + if err != nil { + return "", nil, fmt.Errorf("failed to list pods for deployment %s: %w", name, err) + } + if len(pods.Items) == 0 { + return "", nil, fmt.Errorf("no running pods found for deployment %s/%s", namespace, name) + } + podName := pods.Items[0].Name + + transport, upgrader, err := spdy.RoundTripperFor(cfg) + if err != nil { + return "", nil, fmt.Errorf("failed to create SPDY round tripper: %w", err) + } + + req := clientset.CoreV1().RESTClient().Post(). + Resource("pods"). + Namespace(namespace). + Name(podName). + SubResource("portforward") + + dialer := spdy.NewDialer(upgrader, &http.Client{Transport: transport}, "POST", req.URL()) + + stopChan := make(chan struct{}) + readyChan := make(chan struct{}) + + fw, err := portforward.New(dialer, []string{"0:5000"}, stopChan, readyChan, io.Discard, io.Discard) + if err != nil { + return "", nil, fmt.Errorf("failed to create port forwarder: %w", err) + } + + errChan := make(chan error, 1) + go func() { + errChan <- fw.ForwardPorts() + }() + + select { + case <-readyChan: + ports, err := fw.GetPorts() + if err != nil { + close(stopChan) + return "", nil, fmt.Errorf("failed to get forwarded ports: %w", err) + } + localPort := ports[0].Local + return fmt.Sprintf("localhost:%d", localPort), func() { close(stopChan) }, nil + case err := <-errChan: + return "", nil, fmt.Errorf("port-forward failed: %w", err) + case <-ctx.Done(): + close(stopChan) + return "", nil, ctx.Err() + } +} diff --git a/test/upgrade-e2e/features/operator-upgrade.feature b/test/upgrade-e2e/features/operator-upgrade.feature index 117211b612..25bc6d6791 100644 --- a/test/upgrade-e2e/features/operator-upgrade.feature +++ b/test/upgrade-e2e/features/operator-upgrade.feature @@ -6,25 +6,29 @@ Feature: Operator upgrade verification Background: Given the latest stable OLM release is installed - And ClusterCatalog "test" serves bundles - And ServiceAccount "olm-sa" with permissions to install extensions is available in "upgrade-ns" namespace + And an image registry is available + And a catalog "test" with packages: + | package | version | channel | replaces | contents | + | test | 1.0.0 | beta | | CRD, Deployment, ConfigMap | + | test | 1.0.1 | beta | 1.0.0 | CRD, Deployment, ConfigMap | + And ServiceAccount "olm-sa" with permissions to install extensions is available in "${TEST_NAMESPACE}" namespace And ClusterExtension is applied """ apiVersion: olm.operatorframework.io/v1 kind: ClusterExtension metadata: - name: upgrade-ce + name: ${NAME} spec: - namespace: upgrade-ns + namespace: ${TEST_NAMESPACE} serviceAccount: name: olm-sa source: sourceType: Catalog catalog: - packageName: test + packageName: ${PACKAGE:test} selector: matchLabels: - "olm.operatorframework.io/metadata.name": test-catalog + "olm.operatorframework.io/metadata.name": ${CATALOG:test} version: 1.0.0 """ And ClusterExtension is available @@ -33,12 +37,12 @@ Feature: Operator upgrade verification And operator-controller is ready to reconcile resources Scenario: ClusterCatalog continues unpacking after OLM upgrade - When ClusterCatalog is reconciled - Then ClusterCatalog reports Progressing as True with Reason Succeeded - And ClusterCatalog reports Serving as True with Reason Available + When catalog "test" is reconciled + Then catalog "test" reports Progressing as True with Reason Succeeded + And catalog "test" reports Serving as True with Reason Available Scenario: ClusterExtension remains functional after OLM upgrade Given ClusterExtension is reconciled When ClusterExtension is updated to version "1.0.1" Then ClusterExtension is available - And bundle "test-operator.1.0.1" is installed in version "1.0.1" + And bundle "${PACKAGE:test}.1.0.1" is installed in version "1.0.1" diff --git a/testdata/Dockerfile b/testdata/Dockerfile deleted file mode 100644 index 0bee4012bf..0000000000 --- a/testdata/Dockerfile +++ /dev/null @@ -1,9 +0,0 @@ -FROM gcr.io/distroless/static:nonroot - -WORKDIR / - -COPY push/bin/push push - -COPY images images - -USER 65532:65532 diff --git a/testdata/build-test-registry.sh b/testdata/build-test-registry.sh index e2dcc09148..81ff61b10c 100755 --- a/testdata/build-test-registry.sh +++ b/testdata/build-test-registry.sh @@ -1,138 +1,4 @@ #!/bin/bash - -set -o errexit -set -o nounset -set -o pipefail - -help=" -build-test-registry.sh is a script to stand up an image registry within a cluster. -Usage: - build-test-registry.sh [NAMESPACE] [NAME] [IMAGE] - -Argument Descriptions: - - NAMESPACE is the namespace that should be created and is the namespace in which the image registry will be created - - NAME is the name that should be used for the image registry Deployment and Service - - IMAGE is the name of the image that should be used to run the image registry -" - -if [[ "$#" -ne 3 ]]; then - echo "Illegal number of arguments passed" - echo "${help}" - exit 1 -fi - -namespace=$1 -name=$2 -image=$3 - -kubectl apply -f - << EOF -apiVersion: v1 -kind: Namespace -metadata: - name: ${namespace} ---- -apiVersion: cert-manager.io/v1 -kind: Certificate -metadata: - name: ${namespace}-registry - namespace: ${namespace} -spec: - secretName: ${namespace}-registry - isCA: true - dnsNames: - - ${name}.${namespace}.svc - - ${name}.${namespace}.svc.cluster.local - - ${name}-controller-manager-metrics-service.${namespace}.svc - - ${name}-controller-manager-metrics-service.${namespace}.svc.cluster.local - privateKey: - rotationPolicy: Always - algorithm: ECDSA - size: 256 - issuerRef: - name: olmv1-ca - kind: ClusterIssuer - group: cert-manager.io ---- -apiVersion: apps/v1 -kind: Deployment -metadata: - name: ${name} - namespace: ${namespace} - labels: - app: registry -spec: - replicas: 1 - selector: - matchLabels: - app: registry - template: - metadata: - labels: - app: registry - spec: - containers: - - name: registry - image: registry:3 - imagePullPolicy: IfNotPresent - volumeMounts: - - name: certs-vol - mountPath: "/certs" - env: - - name: REGISTRY_HTTP_TLS_CERTIFICATE - value: "/certs/tls.crt" - - name: REGISTRY_HTTP_TLS_KEY - value: "/certs/tls.key" - volumes: - - name: certs-vol - secret: - secretName: ${namespace}-registry ---- -apiVersion: v1 -kind: Service -metadata: - name: ${name} - namespace: ${namespace} -spec: - selector: - app: registry - ports: - - name: http - port: 5000 - targetPort: 5000 - nodePort: 30000 - type: NodePort -EOF - -kubectl wait --for=condition=Available -n "${namespace}" "deploy/${name}" --timeout=60s - -kubectl apply -f - << EOF -apiVersion: batch/v1 -kind: Job -metadata: - name: ${name}-push - namespace: "${namespace}" -spec: - template: - spec: - restartPolicy: Never - containers: - - name: push - image: ${image} - command: - - /push - args: - - "--registry-address=${name}.${namespace}.svc:5000" - - "--images-path=/images" - volumeMounts: - - name: certs-vol - mountPath: "/certs" - env: - - name: SSL_CERT_DIR - value: "/certs/" - volumes: - - name: certs-vol - secret: - secretName: ${namespace}-registry -EOF - -kubectl wait --for=condition=Complete -n "${namespace}" "job/${name}-push" --timeout=60s +# No-op: test registry is now deployed dynamically by Go test code. +# This stub exists for backward compatibility with downstream CI. +exit 0 diff --git a/testdata/images/bundles/large-crd-operator/v1.0.0/manifests/largecrd.operatorframework.io_largecrdtests.yaml b/testdata/images/bundles/large-crd-operator/v1.0.0/manifests/largecrd.operatorframework.io_largecrdtests.yaml deleted file mode 100644 index 90ea044676..0000000000 --- a/testdata/images/bundles/large-crd-operator/v1.0.0/manifests/largecrd.operatorframework.io_largecrdtests.yaml +++ /dev/null @@ -1,775 +0,0 @@ -apiVersion: apiextensions.k8s.io/v1 -kind: CustomResourceDefinition -metadata: - annotations: - controller-gen.kubebuilder.io/version: v0.16.1 - name: largecrdtests.largecrd.operatorframework.io -spec: - group: largecrd.operatorframework.io - names: - kind: LargeCrdTest - listKind: LargeCrdTestList - plural: largecrdtests - singular: largecrdtest - scope: Cluster - versions: - - name: v1 - served: true - storage: true - schema: - openAPIV3Schema: - type: object - properties: - spec: - type: object - properties: - field0000: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0001: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0002: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0003: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0004: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0005: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0006: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0007: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0008: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0009: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0010: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0011: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0012: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0013: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0014: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0015: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0016: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0017: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0018: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0019: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0020: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0021: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0022: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0023: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0024: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0025: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0026: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0027: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0028: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0029: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0030: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0031: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0032: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0033: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0034: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0035: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0036: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0037: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0038: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0039: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0040: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0041: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0042: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0043: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0044: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0045: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0046: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0047: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0048: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0049: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0050: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0051: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0052: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0053: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0054: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0055: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0056: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0057: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0058: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0059: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0060: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0061: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0062: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0063: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0064: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0065: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0066: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0067: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0068: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0069: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0070: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0071: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0072: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0073: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0074: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0075: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0076: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0077: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0078: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0079: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0080: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0081: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0082: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0083: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0084: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0085: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0086: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0087: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0088: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0089: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0090: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0091: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0092: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0093: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0094: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0095: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0096: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0097: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0098: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0099: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0100: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0101: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0102: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0103: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0104: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0105: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0106: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0107: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0108: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0109: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0110: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0111: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0112: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0113: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0114: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0115: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0116: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0117: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0118: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0119: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0120: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0121: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0122: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0123: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0124: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0125: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0126: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0127: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0128: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0129: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0130: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0131: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0132: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0133: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0134: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0135: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0136: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0137: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0138: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0139: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0140: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0141: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0142: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0143: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0144: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0145: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0146: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0147: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0148: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0149: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0150: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0151: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0152: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0153: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0154: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0155: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0156: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0157: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0158: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0159: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0160: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0161: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0162: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0163: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0164: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0165: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0166: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0167: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0168: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0169: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0170: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0171: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0172: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0173: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0174: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0175: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0176: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0177: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0178: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0179: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0180: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0181: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0182: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0183: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0184: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0185: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0186: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0187: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0188: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0189: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0190: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0191: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0192: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0193: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0194: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0195: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0196: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0197: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0198: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0199: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0200: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0201: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0202: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0203: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0204: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0205: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0206: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0207: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0208: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0209: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0210: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0211: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0212: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0213: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0214: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0215: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0216: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0217: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0218: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0219: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0220: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0221: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0222: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0223: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0224: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0225: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0226: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0227: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0228: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0229: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0230: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0231: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0232: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0233: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0234: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0235: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0236: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0237: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0238: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0239: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0240: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0241: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0242: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0243: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0244: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0245: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0246: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0247: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0248: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" - field0249: - type: string - description: "This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to validate that the OLM installation pipeline correctly handles bundles containing large Custom Resource Definitions. The field accepts a string value that represents a configuration parameter for the operator deployment. This field provides configuration for the large CRD test operator. It is used to valida" diff --git a/testdata/images/bundles/large-crd-operator/v1.0.0/manifests/largecrdoperator.clusterserviceversion.yaml b/testdata/images/bundles/large-crd-operator/v1.0.0/manifests/largecrdoperator.clusterserviceversion.yaml deleted file mode 100644 index b5528ea51a..0000000000 --- a/testdata/images/bundles/large-crd-operator/v1.0.0/manifests/largecrdoperator.clusterserviceversion.yaml +++ /dev/null @@ -1,165 +0,0 @@ -apiVersion: operators.coreos.com/v1alpha1 -kind: ClusterServiceVersion -metadata: - annotations: - alm-examples: |- - [ - { - "apiVersion": "largecrd.operatorframework.io/v1", - "kind": "LargeCrdTest", - "metadata": { - "labels": { - "app.kubernetes.io/managed-by": "kustomize", - "app.kubernetes.io/name": "large-crd-operator" - }, - "name": "largecrdtest-sample" - }, - "spec": null - } - ] - capabilities: Basic Install - createdAt: "2024-10-24T19:21:40Z" - operators.operatorframework.io/builder: operator-sdk-v1.34.1 - operators.operatorframework.io/project_layout: go.kubebuilder.io/v4 - name: large-crd-operator.v1.0.0 - namespace: placeholder -spec: - apiservicedefinitions: {} - customresourcedefinitions: - owned: - - description: LargeCrdTest is a test CRD with a large schema - displayName: LargeCrdTest - kind: LargeCrdTest - name: largecrdtests.largecrd.operatorframework.io - version: v1 - description: OLM E2E Large CRD Testing Operator - displayName: large-crd-operator - icon: - - base64data: "" - mediatype: "" - install: - spec: - deployments: - - label: - app.kubernetes.io/component: controller - app.kubernetes.io/name: large-crd-operator - app.kubernetes.io/version: 1.0.0 - name: large-crd-operator - spec: - replicas: 1 - selector: - matchLabels: - app: largecrdtest - template: - metadata: - labels: - app: largecrdtest - spec: - serviceAccountName: simple-bundle-manager - terminationGracePeriodSeconds: 0 - volumes: - - name: scripts - configMap: - name: httpd-script - defaultMode: 0755 - containers: - - name: busybox-httpd-container - image: busybox:1.37 - command: ["/scripts/httpd.sh"] - ports: - - containerPort: 80 - volumeMounts: - - name: scripts - mountPath: /scripts - readOnly: true - startupProbe: - httpGet: - path: /started - port: 80 - failureThreshold: 30 - periodSeconds: 10 - livenessProbe: - httpGet: - path: /live - port: 80 - failureThreshold: 1 - periodSeconds: 2 - readinessProbe: - httpGet: - path: /ready - port: 80 - initialDelaySeconds: 1 - periodSeconds: 1 - clusterPermissions: - - rules: - - apiGroups: - - authentication.k8s.io - resources: - - tokenreviews - verbs: - - create - - apiGroups: - - authorization.k8s.io - resources: - - subjectaccessreviews - verbs: - - create - serviceAccountName: simple-bundle-manager - permissions: - - rules: - - apiGroups: - - "" - resources: - - configmaps - - serviceaccounts - verbs: - - get - - list - - watch - - create - - update - - patch - - delete - - apiGroups: - - coordination.k8s.io - resources: - - leases - verbs: - - get - - list - - watch - - create - - update - - patch - - delete - - apiGroups: - - "" - resources: - - events - verbs: - - create - - patch - serviceAccountName: simple-bundle-manager - strategy: deployment - installModes: - - supported: false - type: OwnNamespace - - supported: true - type: SingleNamespace - - supported: false - type: MultiNamespace - - supported: true - type: AllNamespaces - keywords: - - registry - links: - - name: large-crd-operator - url: https://large-crd-operator.domain - maintainers: - - email: main#large-crd-operator.domain - name: Large CRD Operator - maturity: beta - provider: - name: Large CRD Operator - url: https://large-crd-operator.domain - version: 1.0.0 diff --git a/testdata/images/bundles/large-crd-operator/v1.0.0/manifests/script.configmap.yaml b/testdata/images/bundles/large-crd-operator/v1.0.0/manifests/script.configmap.yaml deleted file mode 100644 index bfbfe27b93..0000000000 --- a/testdata/images/bundles/large-crd-operator/v1.0.0/manifests/script.configmap.yaml +++ /dev/null @@ -1,12 +0,0 @@ -apiVersion: v1 -kind: ConfigMap -metadata: - name: httpd-script -data: - httpd.sh: | - #!/bin/sh - echo "Version 1.0.0" - echo true > /var/www/started - echo true > /var/www/ready - echo true > /var/www/live - exec httpd -f -h /var/www -p 80 diff --git a/testdata/images/bundles/large-crd-operator/v1.0.0/metadata/annotations.yaml b/testdata/images/bundles/large-crd-operator/v1.0.0/metadata/annotations.yaml deleted file mode 100644 index 41c621e339..0000000000 --- a/testdata/images/bundles/large-crd-operator/v1.0.0/metadata/annotations.yaml +++ /dev/null @@ -1,10 +0,0 @@ -annotations: - # Core bundle annotations. - operators.operatorframework.io.bundle.mediatype.v1: registry+v1 - operators.operatorframework.io.bundle.manifests.v1: manifests/ - operators.operatorframework.io.bundle.metadata.v1: metadata/ - operators.operatorframework.io.bundle.package.v1: large-crd-operator - operators.operatorframework.io.bundle.channels.v1: beta - operators.operatorframework.io.metrics.builder: operator-sdk-v1.28.0 - operators.operatorframework.io.metrics.mediatype.v1: metrics+v1 - operators.operatorframework.io.metrics.project_layout: unknown diff --git a/testdata/images/bundles/own-namespace-operator/v1.0.0/manifests/olm.operatorframework.com_ownnamespaces.yaml b/testdata/images/bundles/own-namespace-operator/v1.0.0/manifests/olm.operatorframework.com_ownnamespaces.yaml deleted file mode 100644 index 305e3c73e8..0000000000 --- a/testdata/images/bundles/own-namespace-operator/v1.0.0/manifests/olm.operatorframework.com_ownnamespaces.yaml +++ /dev/null @@ -1,27 +0,0 @@ -apiVersion: apiextensions.k8s.io/v1 -kind: CustomResourceDefinition -metadata: - annotations: - controller-gen.kubebuilder.io/version: v0.16.1 - name: ownnamespaces.olm.operatorframework.io -spec: - group: olm.operatorframework.io - names: - kind: OwnNamespace - listKind: OwnNamespaceList - plural: ownnamespaces - singular: ownnamespace - scope: Cluster - versions: - - name: v1 - served: true - storage: true - schema: - openAPIV3Schema: - type: object - properties: - spec: - type: object - properties: - testField: - type: string diff --git a/testdata/images/bundles/own-namespace-operator/v1.0.0/manifests/ownnamespaceoperator.clusterserviceversion.yaml b/testdata/images/bundles/own-namespace-operator/v1.0.0/manifests/ownnamespaceoperator.clusterserviceversion.yaml deleted file mode 100644 index de0af1d40a..0000000000 --- a/testdata/images/bundles/own-namespace-operator/v1.0.0/manifests/ownnamespaceoperator.clusterserviceversion.yaml +++ /dev/null @@ -1,151 +0,0 @@ -apiVersion: operators.coreos.com/v1alpha1 -kind: ClusterServiceVersion -metadata: - annotations: - alm-examples: |- - [ - { - "apiVersion": "ownnamespaces.olm.operatorframework.io/v1", - "kind": "OwnNamespace", - "metadata": { - "labels": { - "app.kubernetes.io/managed-by": "kustomize", - "app.kubernetes.io/name": "test" - }, - "name": "test-sample" - }, - "spec": null - } - ] - capabilities: Basic Install - createdAt: "2024-10-24T19:21:40Z" - operators.operatorframework.io/builder: operator-sdk-v1.34.1 - operators.operatorframework.io/project_layout: go.kubebuilder.io/v4 - name: ownnamespaceoperator.v1.0.0 - namespace: placeholder -spec: - apiservicedefinitions: {} - customresourcedefinitions: - owned: - - description: A dummy resource for an operator that only supports own namespace install mode - displayName: OwnNamespace - kind: OwnNamespace - name: ownnamespaces.olm.operatorframework.io - version: v1 - description: OLM OwnNamespace Testing Operator - displayName: test-operator - icon: - - base64data: "" - mediatype: "" - install: - spec: - deployments: - - label: - app.kubernetes.io/component: controller - app.kubernetes.io/name: own-namespace-operator - app.kubernetes.io/version: 1.0.0 - name: own-namespace-operator - spec: - replicas: 1 - selector: - matchLabels: - app: ownnamespacetest - template: - metadata: - labels: - app: ownnamespacetest - spec: - serviceAccountName: simple-bundle-manager - terminationGracePeriodSeconds: 0 - containers: - - name: busybox - image: busybox:1.36 - command: - - 'sleep' - - '1000' - securityContext: - runAsUser: 1000 - runAsNonRoot: true - clusterPermissions: - - rules: - - apiGroups: - - authentication.k8s.io - resources: - - tokenreviews - verbs: - - create - - apiGroups: - - authorization.k8s.io - resources: - - subjectaccessreviews - verbs: - - create - serviceAccountName: simple-bundle-manager - permissions: - - rules: - - apiGroups: - - "" - resources: - - configmaps - - serviceaccounts - verbs: - - get - - list - - watch - - create - - update - - patch - - delete - - apiGroups: - - networking.k8s.io - resources: - - networkpolicies - verbs: - - get - - list - - create - - update - - delete - - apiGroups: - - coordination.k8s.io - resources: - - leases - verbs: - - get - - list - - watch - - create - - update - - patch - - delete - - apiGroups: - - "" - resources: - - events - verbs: - - create - - patch - serviceAccountName: simple-bundle-manager - strategy: deployment - installModes: - - supported: true - type: OwnNamespace - - supported: false - type: SingleNamespace - - supported: false - type: MultiNamespace - - supported: false - type: AllNamespaces - keywords: - - registry - links: - - name: simple-bundle - url: https://simple-bundle.domain - maintainers: - - email: main#simple-bundle.domain - name: Simple Bundle - maturity: beta - provider: - name: Simple Bundle - url: https://simple-bundle.domain - version: 1.0.0 diff --git a/testdata/images/bundles/own-namespace-operator/v1.0.0/metadata/annotations.yaml b/testdata/images/bundles/own-namespace-operator/v1.0.0/metadata/annotations.yaml deleted file mode 100644 index 24cf5213a1..0000000000 --- a/testdata/images/bundles/own-namespace-operator/v1.0.0/metadata/annotations.yaml +++ /dev/null @@ -1,10 +0,0 @@ -annotations: - # Core bundle annotations. - operators.operatorframework.io.bundle.mediatype.v1: registry+v1 - operators.operatorframework.io.bundle.manifests.v1: manifests/ - operators.operatorframework.io.bundle.metadata.v1: metadata/ - operators.operatorframework.io.bundle.package.v1: own-namespace-operator - operators.operatorframework.io.bundle.channels.v1: alpha - operators.operatorframework.io.metrics.builder: operator-sdk-v1.28.0 - operators.operatorframework.io.metrics.mediatype.v1: metrics+v1 - operators.operatorframework.io.metrics.project_layout: unknown diff --git a/testdata/images/bundles/single-namespace-operator/v1.0.0/manifests/olm.operatorframework.com_singlenamespaces.yaml b/testdata/images/bundles/single-namespace-operator/v1.0.0/manifests/olm.operatorframework.com_singlenamespaces.yaml deleted file mode 100644 index 5f8d305434..0000000000 --- a/testdata/images/bundles/single-namespace-operator/v1.0.0/manifests/olm.operatorframework.com_singlenamespaces.yaml +++ /dev/null @@ -1,27 +0,0 @@ -apiVersion: apiextensions.k8s.io/v1 -kind: CustomResourceDefinition -metadata: - annotations: - controller-gen.kubebuilder.io/version: v0.16.1 - name: singlenamespaces.olm.operatorframework.io -spec: - group: olm.operatorframework.io - names: - kind: SingleNamespace - listKind: SingleNamespaceList - plural: singlenamespaces - singular: singlenamespace - scope: Cluster - versions: - - name: v1 - served: true - storage: true - schema: - openAPIV3Schema: - type: object - properties: - spec: - type: object - properties: - testField: - type: string diff --git a/testdata/images/bundles/single-namespace-operator/v1.0.0/manifests/singlenamespaceoperator.clusterserviceversion.yaml b/testdata/images/bundles/single-namespace-operator/v1.0.0/manifests/singlenamespaceoperator.clusterserviceversion.yaml deleted file mode 100644 index c29519eb89..0000000000 --- a/testdata/images/bundles/single-namespace-operator/v1.0.0/manifests/singlenamespaceoperator.clusterserviceversion.yaml +++ /dev/null @@ -1,151 +0,0 @@ -apiVersion: operators.coreos.com/v1alpha1 -kind: ClusterServiceVersion -metadata: - annotations: - alm-examples: |- - [ - { - "apiVersion": "singlenamespaces.olm.operatorframework.io/v1", - "kind": "SingleNamespace", - "metadata": { - "labels": { - "app.kubernetes.io/managed-by": "kustomize", - "app.kubernetes.io/name": "test" - }, - "name": "test-sample" - }, - "spec": null - } - ] - capabilities: Basic Install - createdAt: "2024-10-24T19:21:40Z" - operators.operatorframework.io/builder: operator-sdk-v1.34.1 - operators.operatorframework.io/project_layout: go.kubebuilder.io/v4 - name: singlenamespaceoperator.v1.0.0 - namespace: placeholder -spec: - apiservicedefinitions: {} - customresourcedefinitions: - owned: - - description: A dummy resource for an operator that only supports single namespace install mode - displayName: SingleNamespace - kind: SingleNamespace - name: singlenamespaces.olm.operatorframework.io - version: v1 - description: OLM SingleNamespace Testing Operator - displayName: test-operator - icon: - - base64data: "" - mediatype: "" - install: - spec: - deployments: - - label: - app.kubernetes.io/component: controller - app.kubernetes.io/name: single-namespace-operator - app.kubernetes.io/version: 1.0.0 - name: single-namespace-operator - spec: - replicas: 1 - selector: - matchLabels: - app: singlenamespacetest - template: - metadata: - labels: - app: singlenamespacetest - spec: - serviceAccountName: simple-bundle-manager - terminationGracePeriodSeconds: 0 - containers: - - name: busybox - image: busybox:1.36 - command: - - 'sleep' - - '1000' - securityContext: - runAsUser: 1000 - runAsNonRoot: true - clusterPermissions: - - rules: - - apiGroups: - - authentication.k8s.io - resources: - - tokenreviews - verbs: - - create - - apiGroups: - - authorization.k8s.io - resources: - - subjectaccessreviews - verbs: - - create - serviceAccountName: simple-bundle-manager - permissions: - - rules: - - apiGroups: - - "" - resources: - - configmaps - - serviceaccounts - verbs: - - get - - list - - watch - - create - - update - - patch - - delete - - apiGroups: - - networking.k8s.io - resources: - - networkpolicies - verbs: - - get - - list - - create - - update - - delete - - apiGroups: - - coordination.k8s.io - resources: - - leases - verbs: - - get - - list - - watch - - create - - update - - patch - - delete - - apiGroups: - - "" - resources: - - events - verbs: - - create - - patch - serviceAccountName: simple-bundle-manager - strategy: deployment - installModes: - - supported: false - type: OwnNamespace - - supported: true - type: SingleNamespace - - supported: false - type: MultiNamespace - - supported: false - type: AllNamespaces - keywords: - - registry - links: - - name: simple-bundle - url: https://simple-bundle.domain - maintainers: - - email: main#simple-bundle.domain - name: Simple Bundle - maturity: beta - provider: - name: Simple Bundle - url: https://simple-bundle.domain - version: 1.0.0 diff --git a/testdata/images/bundles/single-namespace-operator/v1.0.0/metadata/annotations.yaml b/testdata/images/bundles/single-namespace-operator/v1.0.0/metadata/annotations.yaml deleted file mode 100644 index b7d60e6df0..0000000000 --- a/testdata/images/bundles/single-namespace-operator/v1.0.0/metadata/annotations.yaml +++ /dev/null @@ -1,10 +0,0 @@ -annotations: - # Core bundle annotations. - operators.operatorframework.io.bundle.mediatype.v1: registry+v1 - operators.operatorframework.io.bundle.manifests.v1: manifests/ - operators.operatorframework.io.bundle.metadata.v1: metadata/ - operators.operatorframework.io.bundle.package.v1: single-namespace-operator - operators.operatorframework.io.bundle.channels.v1: alpha - operators.operatorframework.io.metrics.builder: operator-sdk-v1.28.0 - operators.operatorframework.io.metrics.mediatype.v1: metrics+v1 - operators.operatorframework.io.metrics.project_layout: unknown diff --git a/testdata/images/bundles/test-operator/v1.0.0/manifests/bundle.configmap.yaml b/testdata/images/bundles/test-operator/v1.0.0/manifests/bundle.configmap.yaml deleted file mode 100644 index 74a3623ee7..0000000000 --- a/testdata/images/bundles/test-operator/v1.0.0/manifests/bundle.configmap.yaml +++ /dev/null @@ -1,11 +0,0 @@ -apiVersion: v1 -kind: ConfigMap -metadata: - name: test-configmap - annotations: - shouldNotTemplate: > - The namespace is {{ $labels.namespace }}. The templated $labels.namespace is NOT expected to be processed by OLM's rendering engine for registry+v1 bundles. - -data: - version: "v1.0.0" - name: "test-configmap" diff --git a/testdata/images/bundles/test-operator/v1.0.0/manifests/dummy.configmap.yaml b/testdata/images/bundles/test-operator/v1.0.0/manifests/dummy.configmap.yaml deleted file mode 100644 index 8135b6f178..0000000000 --- a/testdata/images/bundles/test-operator/v1.0.0/manifests/dummy.configmap.yaml +++ /dev/null @@ -1,6 +0,0 @@ -apiVersion: v1 -kind: ConfigMap -metadata: - name: dummy-configmap -data: - why: "this config map does not exist in higher versions of the bundle - it is useful to test whether resources removed between versions are removed from the cluster as well" diff --git a/testdata/images/bundles/test-operator/v1.0.0/manifests/olm.operatorframework.com_olme2etest.yaml b/testdata/images/bundles/test-operator/v1.0.0/manifests/olm.operatorframework.com_olme2etest.yaml deleted file mode 100644 index 44e64cef79..0000000000 --- a/testdata/images/bundles/test-operator/v1.0.0/manifests/olm.operatorframework.com_olme2etest.yaml +++ /dev/null @@ -1,27 +0,0 @@ -apiVersion: apiextensions.k8s.io/v1 -kind: CustomResourceDefinition -metadata: - annotations: - controller-gen.kubebuilder.io/version: v0.16.1 - name: olme2etests.olm.operatorframework.io -spec: - group: olm.operatorframework.io - names: - kind: OLME2ETest - listKind: OLME2ETestList - plural: olme2etests - singular: olme2etest - scope: Cluster - versions: - - name: v1 - served: true - storage: true - schema: - openAPIV3Schema: - type: object - properties: - spec: - type: object - properties: - testField: - type: string diff --git a/testdata/images/bundles/test-operator/v1.0.0/manifests/script.configmap.yaml b/testdata/images/bundles/test-operator/v1.0.0/manifests/script.configmap.yaml deleted file mode 100644 index a0404835a0..0000000000 --- a/testdata/images/bundles/test-operator/v1.0.0/manifests/script.configmap.yaml +++ /dev/null @@ -1,11 +0,0 @@ -apiVersion: v1 -kind: ConfigMap -metadata: - name: httpd-script -data: - httpd.sh: | - #!/bin/sh - echo true > /var/www/started - echo true > /var/www/ready - echo true > /var/www/live - exec httpd -f -h /var/www -p 80 diff --git a/testdata/images/bundles/test-operator/v1.0.0/manifests/testoperator.clusterserviceversion.yaml b/testdata/images/bundles/test-operator/v1.0.0/manifests/testoperator.clusterserviceversion.yaml deleted file mode 100644 index d8cbae85a5..0000000000 --- a/testdata/images/bundles/test-operator/v1.0.0/manifests/testoperator.clusterserviceversion.yaml +++ /dev/null @@ -1,175 +0,0 @@ -apiVersion: operators.coreos.com/v1alpha1 -kind: ClusterServiceVersion -metadata: - annotations: - alm-examples: |- - [ - { - "apiVersion": "olme2etests.olm.operatorframework.io/v1", - "kind": "OLME2ETests", - "metadata": { - "labels": { - "app.kubernetes.io/managed-by": "kustomize", - "app.kubernetes.io/name": "test" - }, - "name": "test-sample" - }, - "spec": null - } - ] - capabilities: Basic Install - createdAt: "2024-10-24T19:21:40Z" - operators.operatorframework.io/builder: operator-sdk-v1.34.1 - operators.operatorframework.io/project_layout: go.kubebuilder.io/v4 - name: testoperator.v1.0.0 - namespace: placeholder -spec: - apiservicedefinitions: {} - customresourcedefinitions: - owned: - - description: Configures subsections of Alertmanager configuration specific to each namespace - displayName: OLME2ETest - kind: OLME2ETest - name: olme2etests.olm.operatorframework.io - version: v1 - description: OLM E2E Testing Operator - displayName: test-operator - icon: - - base64data: "" - mediatype: "" - install: - spec: - deployments: - - label: - app.kubernetes.io/component: controller - app.kubernetes.io/name: test-operator - app.kubernetes.io/version: 1.0.0 - name: test-operator - spec: - replicas: 1 - selector: - matchLabels: - app: olme2etest - template: - metadata: - labels: - app: olme2etest - spec: - serviceAccountName: simple-bundle-manager - terminationGracePeriodSeconds: 0 - volumes: - - name: scripts - configMap: - name: httpd-script - defaultMode: 0755 - containers: - - name: busybox-httpd-container - image: busybox:1.36 - command: ["/scripts/httpd.sh"] - ports: - - containerPort: 80 - volumeMounts: - - name: scripts - mountPath: /scripts - readOnly: true - startupProbe: - httpGet: - path: /started - port: 80 - failureThreshold: 30 - periodSeconds: 10 - livenessProbe: - httpGet: - path: /live - port: 80 - failureThreshold: 1 - periodSeconds: 2 - readinessProbe: - httpGet: - path: /ready - port: 80 - initialDelaySeconds: 1 - periodSeconds: 1 - clusterPermissions: - - rules: - - apiGroups: - - authentication.k8s.io - resources: - - tokenreviews - verbs: - - create - - apiGroups: - - authorization.k8s.io - resources: - - subjectaccessreviews - verbs: - - create - serviceAccountName: simple-bundle-manager - permissions: - - rules: - - apiGroups: - - "" - resources: - - configmaps - - serviceaccounts - verbs: - - get - - list - - watch - - create - - update - - patch - - delete - - apiGroups: - - networking.k8s.io - resources: - - networkpolicies - verbs: - - get - - list - - create - - update - - delete - - apiGroups: - - coordination.k8s.io - resources: - - leases - verbs: - - get - - list - - watch - - create - - update - - patch - - delete - - apiGroups: - - "" - resources: - - events - verbs: - - create - - patch - serviceAccountName: simple-bundle-manager - strategy: deployment - installModes: - - supported: false - type: OwnNamespace - - supported: true - type: SingleNamespace - - supported: false - type: MultiNamespace - - supported: true - type: AllNamespaces - keywords: - - registry - links: - - name: simple-bundle - url: https://simple-bundle.domain - maintainers: - - email: main#simple-bundle.domain - name: Simple Bundle - maturity: beta - provider: - name: Simple Bundle - url: https://simple-bundle.domain - version: 1.0.0 diff --git a/testdata/images/bundles/test-operator/v1.0.0/manifests/testoperator.networkpolicy.yaml b/testdata/images/bundles/test-operator/v1.0.0/manifests/testoperator.networkpolicy.yaml deleted file mode 100644 index 20a5ea834f..0000000000 --- a/testdata/images/bundles/test-operator/v1.0.0/manifests/testoperator.networkpolicy.yaml +++ /dev/null @@ -1,8 +0,0 @@ -apiVersion: networking.k8s.io/v1 -kind: NetworkPolicy -metadata: - name: test-operator-network-policy -spec: - podSelector: {} - policyTypes: - - Ingress diff --git a/testdata/images/bundles/test-operator/v1.0.0/metadata/annotations.yaml b/testdata/images/bundles/test-operator/v1.0.0/metadata/annotations.yaml deleted file mode 100644 index 404f0f4a34..0000000000 --- a/testdata/images/bundles/test-operator/v1.0.0/metadata/annotations.yaml +++ /dev/null @@ -1,10 +0,0 @@ -annotations: - # Core bundle annotations. - operators.operatorframework.io.bundle.mediatype.v1: registry+v1 - operators.operatorframework.io.bundle.manifests.v1: manifests/ - operators.operatorframework.io.bundle.metadata.v1: metadata/ - operators.operatorframework.io.bundle.package.v1: test - operators.operatorframework.io.bundle.channels.v1: beta - operators.operatorframework.io.metrics.builder: operator-sdk-v1.28.0 - operators.operatorframework.io.metrics.mediatype.v1: metrics+v1 - operators.operatorframework.io.metrics.project_layout: unknown diff --git a/testdata/images/bundles/test-operator/v1.0.2/manifests/bundle.configmap.yaml b/testdata/images/bundles/test-operator/v1.0.2/manifests/bundle.configmap.yaml deleted file mode 100644 index 0279603bfc..0000000000 --- a/testdata/images/bundles/test-operator/v1.0.2/manifests/bundle.configmap.yaml +++ /dev/null @@ -1,11 +0,0 @@ -apiVersion: v1 -kind: ConfigMap -metadata: - name: test-configmap - annotations: - shouldNotTemplate: > - The namespace is {{ $labels.namespace }}. The templated $labels.namespace is NOT expected to be processed by OLM's rendering engine for registry+v1 bundles. - -data: - version: "v1.0.2" - name: "test-configmap" diff --git a/testdata/images/bundles/test-operator/v1.0.2/manifests/olm.operatorframework.com_olme2etest.yaml b/testdata/images/bundles/test-operator/v1.0.2/manifests/olm.operatorframework.com_olme2etest.yaml deleted file mode 100644 index 44e64cef79..0000000000 --- a/testdata/images/bundles/test-operator/v1.0.2/manifests/olm.operatorframework.com_olme2etest.yaml +++ /dev/null @@ -1,27 +0,0 @@ -apiVersion: apiextensions.k8s.io/v1 -kind: CustomResourceDefinition -metadata: - annotations: - controller-gen.kubebuilder.io/version: v0.16.1 - name: olme2etests.olm.operatorframework.io -spec: - group: olm.operatorframework.io - names: - kind: OLME2ETest - listKind: OLME2ETestList - plural: olme2etests - singular: olme2etest - scope: Cluster - versions: - - name: v1 - served: true - storage: true - schema: - openAPIV3Schema: - type: object - properties: - spec: - type: object - properties: - testField: - type: string diff --git a/testdata/images/bundles/test-operator/v1.0.2/manifests/testoperator.clusterserviceversion.yaml b/testdata/images/bundles/test-operator/v1.0.2/manifests/testoperator.clusterserviceversion.yaml deleted file mode 100644 index 70c85be13c..0000000000 --- a/testdata/images/bundles/test-operator/v1.0.2/manifests/testoperator.clusterserviceversion.yaml +++ /dev/null @@ -1,151 +0,0 @@ -apiVersion: operators.coreos.com/v1alpha1 -kind: ClusterServiceVersion -metadata: - annotations: - alm-examples: |- - [ - { - "apiVersion": "olme2etests.olm.operatorframework.io/v1", - "kind": "OLME2ETests", - "metadata": { - "labels": { - "app.kubernetes.io/managed-by": "kustomize", - "app.kubernetes.io/name": "test" - }, - "name": "test-sample" - }, - "spec": null - } - ] - capabilities: Basic Install - createdAt: "2024-10-24T19:21:40Z" - operators.operatorframework.io/builder: operator-sdk-v1.34.1 - operators.operatorframework.io/project_layout: go.kubebuilder.io/v4 - name: testoperator.v1.0.2 - namespace: placeholder -spec: - apiservicedefinitions: {} - customresourcedefinitions: - owned: - - description: Configures subsections of Alertmanager configuration specific to each namespace - displayName: OLME2ETest - kind: OLME2ETest - name: olme2etests.olm.operatorframework.io - version: v1 - description: OLM E2E Testing Operator with a wrong image ref - displayName: test-operator - icon: - - base64data: "" - mediatype: "" - install: - spec: - deployments: - - label: - app.kubernetes.io/component: controller - app.kubernetes.io/name: test-operator - app.kubernetes.io/version: 1.0.2 - name: test-operator - spec: - replicas: 1 - selector: - matchLabels: - app: olme2etest - template: - metadata: - labels: - app: olme2etest - spec: - serviceAccountName: simple-bundle-manager - terminationGracePeriodSeconds: 0 - volumes: - - name: scripts - configMap: - name: httpd-script - defaultMode: 0755 - containers: - - name: busybox-httpd-container - # This image ref is wrong and should trigger ImagePullBackOff condition - image: wrong/image - clusterPermissions: - - rules: - - apiGroups: - - authentication.k8s.io - resources: - - tokenreviews - verbs: - - create - - apiGroups: - - authorization.k8s.io - resources: - - subjectaccessreviews - verbs: - - create - serviceAccountName: simple-bundle-manager - permissions: - - rules: - - apiGroups: - - "" - resources: - - configmaps - - serviceaccounts - verbs: - - get - - list - - watch - - create - - update - - patch - - delete - - apiGroups: - - networking.k8s.io - resources: - - networkpolicies - verbs: - - get - - list - - create - - update - - delete - - apiGroups: - - coordination.k8s.io - resources: - - leases - verbs: - - get - - list - - watch - - create - - update - - patch - - delete - - apiGroups: - - "" - resources: - - events - verbs: - - create - - patch - serviceAccountName: simple-bundle-manager - strategy: deployment - installModes: - - supported: false - type: OwnNamespace - - supported: true - type: SingleNamespace - - supported: false - type: MultiNamespace - - supported: true - type: AllNamespaces - keywords: - - registry - links: - - name: simple-bundle - url: https://simple-bundle.domain - maintainers: - - email: main#simple-bundle.domain - name: Simple Bundle - maturity: beta - provider: - name: Simple Bundle - url: https://simple-bundle.domain - version: 1.0.2 diff --git a/testdata/images/bundles/test-operator/v1.0.2/manifests/testoperator.networkpolicy.yaml b/testdata/images/bundles/test-operator/v1.0.2/manifests/testoperator.networkpolicy.yaml deleted file mode 100644 index 20a5ea834f..0000000000 --- a/testdata/images/bundles/test-operator/v1.0.2/manifests/testoperator.networkpolicy.yaml +++ /dev/null @@ -1,8 +0,0 @@ -apiVersion: networking.k8s.io/v1 -kind: NetworkPolicy -metadata: - name: test-operator-network-policy -spec: - podSelector: {} - policyTypes: - - Ingress diff --git a/testdata/images/bundles/test-operator/v1.0.2/metadata/annotations.yaml b/testdata/images/bundles/test-operator/v1.0.2/metadata/annotations.yaml deleted file mode 100644 index 404f0f4a34..0000000000 --- a/testdata/images/bundles/test-operator/v1.0.2/metadata/annotations.yaml +++ /dev/null @@ -1,10 +0,0 @@ -annotations: - # Core bundle annotations. - operators.operatorframework.io.bundle.mediatype.v1: registry+v1 - operators.operatorframework.io.bundle.manifests.v1: manifests/ - operators.operatorframework.io.bundle.metadata.v1: metadata/ - operators.operatorframework.io.bundle.package.v1: test - operators.operatorframework.io.bundle.channels.v1: beta - operators.operatorframework.io.metrics.builder: operator-sdk-v1.28.0 - operators.operatorframework.io.metrics.mediatype.v1: metrics+v1 - operators.operatorframework.io.metrics.project_layout: unknown diff --git a/testdata/images/bundles/test-operator/v1.0.3/manifests/bundle.configmap.yaml b/testdata/images/bundles/test-operator/v1.0.3/manifests/bundle.configmap.yaml deleted file mode 100644 index 43b73e2c70..0000000000 --- a/testdata/images/bundles/test-operator/v1.0.3/manifests/bundle.configmap.yaml +++ /dev/null @@ -1,7 +0,0 @@ -apiVersion: v1 -kind: ConfigMap -metadata: - name: wrong-test-configmap -# need such config map with a wrong field so that we can reach progression deadline timeouts -wrongfield: - name: "test-configmap" diff --git a/testdata/images/bundles/test-operator/v1.0.3/manifests/testoperator.clusterserviceversion.yaml b/testdata/images/bundles/test-operator/v1.0.3/manifests/testoperator.clusterserviceversion.yaml deleted file mode 100644 index 8414e78ae1..0000000000 --- a/testdata/images/bundles/test-operator/v1.0.3/manifests/testoperator.clusterserviceversion.yaml +++ /dev/null @@ -1,151 +0,0 @@ -apiVersion: operators.coreos.com/v1alpha1 -kind: ClusterServiceVersion -metadata: - annotations: - alm-examples: |- - [ - { - "apiVersion": "olme2etests.olm.operatorframework.io/v1", - "kind": "OLME2ETests", - "metadata": { - "labels": { - "app.kubernetes.io/managed-by": "kustomize", - "app.kubernetes.io/name": "test" - }, - "name": "test-sample" - }, - "spec": null - } - ] - capabilities: Basic Install - createdAt: "2024-10-24T19:21:40Z" - operators.operatorframework.io/builder: operator-sdk-v1.34.1 - operators.operatorframework.io/project_layout: go.kubebuilder.io/v4 - name: testoperator.v1.0.2 - namespace: placeholder -spec: - apiservicedefinitions: {} - customresourcedefinitions: - owned: - - description: Configures subsections of Alertmanager configuration specific to each namespace - displayName: OLME2ETest - kind: OLME2ETest - name: olme2etests.olm.operatorframework.io - version: v1 - description: OLM E2E Testing Operator with a wrong image ref - displayName: test-operator - icon: - - base64data: "" - mediatype: "" - install: - spec: - deployments: - - label: - app.kubernetes.io/component: controller - app.kubernetes.io/name: test-operator - app.kubernetes.io/version: 1.0.2 - name: test-operator - spec: - replicas: 1 - selector: - matchLabels: - app: olme2etest - template: - metadata: - labels: - app: olme2etest - spec: - serviceAccountName: simple-bundle-manager - terminationGracePeriodSeconds: 0 - volumes: - - name: scripts - configMap: - name: httpd-script - defaultMode: 0755 - containers: - - name: busybox-httpd-container - # This image ref is wrong and should trigger ImagePullBackOff condition - image: busybox:1.36 - clusterPermissions: - - rules: - - apiGroups: - - authentication.k8s.io - resources: - - tokenreviews - verbs: - - create - - apiGroups: - - authorization.k8s.io - resources: - - subjectaccessreviews - verbs: - - create - serviceAccountName: simple-bundle-manager - permissions: - - rules: - - apiGroups: - - "" - resources: - - configmaps - - serviceaccounts - verbs: - - get - - list - - watch - - create - - update - - patch - - delete - - apiGroups: - - networking.k8s.io - resources: - - networkpolicies - verbs: - - get - - list - - create - - update - - delete - - apiGroups: - - coordination.k8s.io - resources: - - leases - verbs: - - get - - list - - watch - - create - - update - - patch - - delete - - apiGroups: - - "" - resources: - - events - verbs: - - create - - patch - serviceAccountName: simple-bundle-manager - strategy: deployment - installModes: - - supported: false - type: OwnNamespace - - supported: true - type: SingleNamespace - - supported: false - type: MultiNamespace - - supported: true - type: AllNamespaces - keywords: - - registry - links: - - name: simple-bundle - url: https://simple-bundle.domain - maintainers: - - email: main#simple-bundle.domain - name: Simple Bundle - maturity: beta - provider: - name: Simple Bundle - url: https://simple-bundle.domain - version: 1.0.2 diff --git a/testdata/images/bundles/test-operator/v1.0.3/metadata/annotations.yaml b/testdata/images/bundles/test-operator/v1.0.3/metadata/annotations.yaml deleted file mode 100644 index 404f0f4a34..0000000000 --- a/testdata/images/bundles/test-operator/v1.0.3/metadata/annotations.yaml +++ /dev/null @@ -1,10 +0,0 @@ -annotations: - # Core bundle annotations. - operators.operatorframework.io.bundle.mediatype.v1: registry+v1 - operators.operatorframework.io.bundle.manifests.v1: manifests/ - operators.operatorframework.io.bundle.metadata.v1: metadata/ - operators.operatorframework.io.bundle.package.v1: test - operators.operatorframework.io.bundle.channels.v1: beta - operators.operatorframework.io.metrics.builder: operator-sdk-v1.28.0 - operators.operatorframework.io.metrics.mediatype.v1: metrics+v1 - operators.operatorframework.io.metrics.project_layout: unknown diff --git a/testdata/images/bundles/test-operator/v1.2.0/manifests/bundle.configmap.yaml b/testdata/images/bundles/test-operator/v1.2.0/manifests/bundle.configmap.yaml deleted file mode 100644 index 22ee500908..0000000000 --- a/testdata/images/bundles/test-operator/v1.2.0/manifests/bundle.configmap.yaml +++ /dev/null @@ -1,11 +0,0 @@ -apiVersion: v1 -kind: ConfigMap -metadata: - name: test-configmap - annotations: - shouldNotTemplate: > - The namespace is {{ $labels.namespace }}. The templated $labels.namespace is NOT expected to be processed by OLM's rendering engine for registry+v1 bundles. - -data: - version: "v1.2.0" - name: "test-configmap" diff --git a/testdata/images/bundles/test-operator/v1.2.0/manifests/olm.operatorframework.com_olme2etest.yaml b/testdata/images/bundles/test-operator/v1.2.0/manifests/olm.operatorframework.com_olme2etest.yaml deleted file mode 100644 index 44e64cef79..0000000000 --- a/testdata/images/bundles/test-operator/v1.2.0/manifests/olm.operatorframework.com_olme2etest.yaml +++ /dev/null @@ -1,27 +0,0 @@ -apiVersion: apiextensions.k8s.io/v1 -kind: CustomResourceDefinition -metadata: - annotations: - controller-gen.kubebuilder.io/version: v0.16.1 - name: olme2etests.olm.operatorframework.io -spec: - group: olm.operatorframework.io - names: - kind: OLME2ETest - listKind: OLME2ETestList - plural: olme2etests - singular: olme2etest - scope: Cluster - versions: - - name: v1 - served: true - storage: true - schema: - openAPIV3Schema: - type: object - properties: - spec: - type: object - properties: - testField: - type: string diff --git a/testdata/images/bundles/test-operator/v1.2.0/manifests/script.configmap.yaml b/testdata/images/bundles/test-operator/v1.2.0/manifests/script.configmap.yaml deleted file mode 100644 index 6270e4ad71..0000000000 --- a/testdata/images/bundles/test-operator/v1.2.0/manifests/script.configmap.yaml +++ /dev/null @@ -1,12 +0,0 @@ -apiVersion: v1 -kind: ConfigMap -metadata: - name: httpd-script -data: - httpd.sh: | - #!/bin/sh - echo "Version 1.2.0" - echo true > /var/www/started - echo true > /var/www/ready - echo true > /var/www/live - exec httpd -f -h /var/www -p 80 diff --git a/testdata/images/bundles/test-operator/v1.2.0/manifests/testoperator.clusterserviceversion.yaml b/testdata/images/bundles/test-operator/v1.2.0/manifests/testoperator.clusterserviceversion.yaml deleted file mode 100644 index 2f1aff7a59..0000000000 --- a/testdata/images/bundles/test-operator/v1.2.0/manifests/testoperator.clusterserviceversion.yaml +++ /dev/null @@ -1,175 +0,0 @@ -apiVersion: operators.coreos.com/v1alpha1 -kind: ClusterServiceVersion -metadata: - annotations: - alm-examples: |- - [ - { - "apiVersion": "olme2etests.olm.operatorframework.io/v1", - "kind": "OLME2ETests", - "metadata": { - "labels": { - "app.kubernetes.io/managed-by": "kustomize", - "app.kubernetes.io/name": "test" - }, - "name": "test-sample" - }, - "spec": null - } - ] - capabilities: Basic Install - createdAt: "2024-10-24T19:21:40Z" - operators.operatorframework.io/builder: operator-sdk-v1.34.1 - operators.operatorframework.io/project_layout: go.kubebuilder.io/v4 - name: testoperator.v1.2.0 - namespace: placeholder -spec: - apiservicedefinitions: {} - customresourcedefinitions: - owned: - - description: Configures subsections of Alertmanager configuration specific to each namespace - displayName: OLME2ETest - kind: OLME2ETest - name: olme2etests.olm.operatorframework.io - version: v1 - description: OLM E2E Testing Operator - displayName: test-operator - icon: - - base64data: "" - mediatype: "" - install: - spec: - deployments: - - label: - app.kubernetes.io/component: controller - app.kubernetes.io/name: test-operator - app.kubernetes.io/version: 1.2.0 - name: test-operator - spec: - replicas: 1 - selector: - matchLabels: - app: olme2etest - template: - metadata: - labels: - app: olme2etest - spec: - serviceAccountName: simple-bundle-manager - terminationGracePeriodSeconds: 0 - volumes: - - name: scripts - configMap: - name: httpd-script - defaultMode: 0755 - containers: - - name: busybox-httpd-container - image: busybox:1.37 - command: ["/scripts/httpd.sh"] - ports: - - containerPort: 80 - volumeMounts: - - name: scripts - mountPath: /scripts - readOnly: true - startupProbe: - httpGet: - path: /started - port: 80 - failureThreshold: 30 - periodSeconds: 10 - livenessProbe: - httpGet: - path: /live - port: 80 - failureThreshold: 1 - periodSeconds: 2 - readinessProbe: - httpGet: - path: /ready - port: 80 - initialDelaySeconds: 1 - periodSeconds: 1 - clusterPermissions: - - rules: - - apiGroups: - - authentication.k8s.io - resources: - - tokenreviews - verbs: - - create - - apiGroups: - - authorization.k8s.io - resources: - - subjectaccessreviews - verbs: - - create - serviceAccountName: simple-bundle-manager - permissions: - - rules: - - apiGroups: - - "" - resources: - - configmaps - - serviceaccounts - verbs: - - get - - list - - watch - - create - - update - - patch - - delete - - apiGroups: - - networking.k8s.io - resources: - - networkpolicies - verbs: - - get - - list - - create - - update - - delete - - apiGroups: - - coordination.k8s.io - resources: - - leases - verbs: - - get - - list - - watch - - create - - update - - patch - - delete - - apiGroups: - - "" - resources: - - events - verbs: - - create - - patch - serviceAccountName: simple-bundle-manager - strategy: deployment - installModes: - - supported: false - type: OwnNamespace - - supported: true - type: SingleNamespace - - supported: false - type: MultiNamespace - - supported: true - type: AllNamespaces - keywords: - - registry - links: - - name: simple-bundle - url: https://simple-bundle.domain - maintainers: - - email: main#simple-bundle.domain - name: Simple Bundle - maturity: beta - provider: - name: Simple Bundle - url: https://simple-bundle.domain - version: 1.2.0 diff --git a/testdata/images/bundles/test-operator/v1.2.0/manifests/testoperator.networkpolicy.yaml b/testdata/images/bundles/test-operator/v1.2.0/manifests/testoperator.networkpolicy.yaml deleted file mode 100644 index 20a5ea834f..0000000000 --- a/testdata/images/bundles/test-operator/v1.2.0/manifests/testoperator.networkpolicy.yaml +++ /dev/null @@ -1,8 +0,0 @@ -apiVersion: networking.k8s.io/v1 -kind: NetworkPolicy -metadata: - name: test-operator-network-policy -spec: - podSelector: {} - policyTypes: - - Ingress diff --git a/testdata/images/bundles/test-operator/v1.2.0/metadata/annotations.yaml b/testdata/images/bundles/test-operator/v1.2.0/metadata/annotations.yaml deleted file mode 100644 index 404f0f4a34..0000000000 --- a/testdata/images/bundles/test-operator/v1.2.0/metadata/annotations.yaml +++ /dev/null @@ -1,10 +0,0 @@ -annotations: - # Core bundle annotations. - operators.operatorframework.io.bundle.mediatype.v1: registry+v1 - operators.operatorframework.io.bundle.manifests.v1: manifests/ - operators.operatorframework.io.bundle.metadata.v1: metadata/ - operators.operatorframework.io.bundle.package.v1: test - operators.operatorframework.io.bundle.channels.v1: beta - operators.operatorframework.io.metrics.builder: operator-sdk-v1.28.0 - operators.operatorframework.io.metrics.mediatype.v1: metrics+v1 - operators.operatorframework.io.metrics.project_layout: unknown diff --git a/testdata/images/bundles/test-operator/v1.2.0/metadata/properties.yaml b/testdata/images/bundles/test-operator/v1.2.0/metadata/properties.yaml deleted file mode 100644 index 3a2bfb2a64..0000000000 --- a/testdata/images/bundles/test-operator/v1.2.0/metadata/properties.yaml +++ /dev/null @@ -1,3 +0,0 @@ -properties: - - type: olm.test-property - value: "some-value" diff --git a/testdata/images/catalogs/test-catalog/v1/configs/.indexignore b/testdata/images/catalogs/test-catalog/v1/configs/.indexignore deleted file mode 100644 index 699fa6d33a..0000000000 --- a/testdata/images/catalogs/test-catalog/v1/configs/.indexignore +++ /dev/null @@ -1,2 +0,0 @@ -/expected_all.json -..* diff --git a/testdata/images/catalogs/test-catalog/v1/configs/catalog.yaml b/testdata/images/catalogs/test-catalog/v1/configs/catalog.yaml deleted file mode 100644 index 834c2f3165..0000000000 --- a/testdata/images/catalogs/test-catalog/v1/configs/catalog.yaml +++ /dev/null @@ -1,207 +0,0 @@ -schema: olm.package -name: test -defaultChannel: beta ---- -schema: olm.channel -name: alpha -package: test -entries: - - name: test-operator.1.0.0 - - name: test-operator.1.0.2 - - name: test-operator.1.0.3 ---- -schema: olm.channel -name: beta -package: test -entries: - - name: test-operator.1.0.0 - - name: test-operator.1.0.1 - replaces: test-operator.1.0.0 - - name: test-operator.1.0.4 - - name: test-operator.1.2.0 - replaces: test-operator.1.0.1 ---- -schema: olm.bundle -name: test-operator.1.0.0 -package: test -image: docker-registry.operator-controller-e2e.svc.cluster.local:5000/bundles/registry-v1/test-operator:v1.0.0 -properties: - - type: olm.package - value: - packageName: test - version: 1.0.0 ---- -schema: olm.bundle -name: test-operator.1.0.1 -package: test -image: docker-registry.operator-controller-e2e.svc.cluster.local:5000/bundles/registry-v1/test-operator:v1.0.0 -properties: - - type: olm.package - value: - packageName: test - version: 1.0.1 ---- -# Bundle with identical rendered content as v1.0.0 (same image). -# Used to test that upgrading between versions with identical manifests -# correctly updates the installed version status (OCPBUGS-78311). -schema: olm.bundle -name: test-operator.1.0.4 -package: test -image: docker-registry.operator-controller-e2e.svc.cluster.local:5000/bundles/registry-v1/test-operator:v1.0.0 -properties: - - type: olm.package - value: - packageName: test - version: 1.0.4 ---- -# Bundle with a wrong image ref causing image pull failure -schema: olm.bundle -name: test-operator.1.0.2 -package: test -image: docker-registry.operator-controller-e2e.svc.cluster.local:5000/bundles/registry-v1/test-operator:v1.0.2 -properties: - - type: olm.package - value: - packageName: test - version: 1.0.2 ---- -# Bundle with an invalid config map ensure that we can never successfully rollout - used to test progression deadline timeouts -schema: olm.bundle -name: test-operator.1.0.3 -package: test -image: docker-registry.operator-controller-e2e.svc.cluster.local:5000/bundles/registry-v1/test-operator:v1.0.3 -properties: - - type: olm.package - value: - packageName: test - version: 1.0.3 ---- -schema: olm.bundle -name: test-operator.1.2.0 -package: test -image: docker-registry.operator-controller-e2e.svc.cluster.local:5000/bundles/registry-v1/test-operator:v1.2.0 -properties: - - type: olm.package - value: - packageName: test - version: 1.2.0 ---- -schema: olm.package -name: test-mirrored -defaultChannel: beta ---- -schema: olm.channel -name: beta -package: test-mirrored -entries: - - name: test-mirrored-operator.1.2.0 ---- -schema: olm.bundle -name: test-mirrored-operator.1.2.0 -package: test-mirrored -image: mirrored-registry.operator-controller-e2e.svc.cluster.local:5000/bundles/registry-v1/test-operator:v1.0.0 -properties: - - type: olm.package - value: - packageName: test-mirrored - version: 1.2.0 ---- -schema: olm.package -name: dynamic -defaultChannel: beta ---- -schema: olm.channel -name: beta -package: dynamic -entries: - - name: dynamic-operator.1.2.0 ---- -schema: olm.bundle -name: dynamic-operator.1.2.0 -package: dynamic -image: dynamic-registry.operator-controller-e2e.svc.cluster.local:5000/bundles/registry-v1/test-operator:v1.0.0 -properties: - - type: olm.package - value: - packageName: dynamic - version: 1.2.0 ---- -schema: olm.package -name: webhook-operator -defaultChannel: alpha ---- -schema: olm.channel -name: alpha -package: webhook-operator -entries: - - name: webhook-operator.v0.0.1 ---- -schema: olm.bundle -name: webhook-operator.v0.0.1 -package: webhook-operator -image: docker-registry.operator-controller-e2e.svc.cluster.local:5000/bundles/registry-v1/webhook-operator:v0.0.1 -properties: - - type: olm.package - value: - packageName: webhook-operator - version: 0.0.1 ---- -schema: olm.package -name: own-namespace-operator -defaultChannel: alpha ---- -schema: olm.channel -name: alpha -package: own-namespace-operator -entries: - - name: own-namespace-operator.1.0.0 ---- -schema: olm.bundle -name: own-namespace-operator.1.0.0 -package: own-namespace-operator -image: docker-registry.operator-controller-e2e.svc.cluster.local:5000/bundles/registry-v1/own-namespace-operator:v1.0.0 -properties: - - type: olm.package - value: - packageName: own-namespace-operator - version: 1.0.0 ---- -schema: olm.package -name: single-namespace-operator -defaultChannel: alpha ---- -schema: olm.channel -name: alpha -package: single-namespace-operator -entries: - - name: single-namespace-operator.1.0.0 ---- -schema: olm.bundle -name: single-namespace-operator.1.0.0 -package: single-namespace-operator -image: docker-registry.operator-controller-e2e.svc.cluster.local:5000/bundles/registry-v1/single-namespace-operator:v1.0.0 -properties: - - type: olm.package - value: - packageName: single-namespace-operator - version: 1.0.0 ---- -schema: olm.package -name: large-crd-operator -defaultChannel: beta ---- -schema: olm.channel -name: beta -package: large-crd-operator -entries: - - name: large-crd-operator.1.0.0 ---- -schema: olm.bundle -name: large-crd-operator.1.0.0 -package: large-crd-operator -image: docker-registry.operator-controller-e2e.svc.cluster.local:5000/bundles/registry-v1/large-crd-operator:v1.0.0 -properties: - - type: olm.package - value: - packageName: large-crd-operator - version: 1.0.0 diff --git a/testdata/images/catalogs/test-catalog/v2/configs/.indexignore b/testdata/images/catalogs/test-catalog/v2/configs/.indexignore deleted file mode 100644 index 699fa6d33a..0000000000 --- a/testdata/images/catalogs/test-catalog/v2/configs/.indexignore +++ /dev/null @@ -1,2 +0,0 @@ -/expected_all.json -..* diff --git a/testdata/images/catalogs/test-catalog/v2/configs/catalog.yaml b/testdata/images/catalogs/test-catalog/v2/configs/catalog.yaml deleted file mode 100644 index 2e82b12290..0000000000 --- a/testdata/images/catalogs/test-catalog/v2/configs/catalog.yaml +++ /dev/null @@ -1,20 +0,0 @@ -schema: olm.package -name: test -defaultChannel: beta ---- -schema: olm.channel -name: beta -package: test -entries: - - name: test-operator.1.3.0 - replaces: test-operator.1.2.0 ---- -schema: olm.bundle -name: test-operator.1.3.0 -package: test -image: docker-registry.operator-controller-e2e.svc.cluster.local:5000/bundles/registry-v1/test-operator:v1.0.0 -properties: - - type: olm.package - value: - packageName: test - version: 1.3.0 diff --git a/testdata/push/README.md b/testdata/push/README.md deleted file mode 100644 index 743a984ffb..0000000000 --- a/testdata/push/README.md +++ /dev/null @@ -1,46 +0,0 @@ -# Test Registry Image Push - -This tool builds our test bundle and catalog images via crane. It accepts two command line arguments: -``` -Usage of push: - --images-path string Image directory path (default "/images") - --registry-address string The address of the registry. (default ":12345") -``` - -`--registry-address` is the address of the registry to be pushed to. - -`--images-path` should point to the root directory of the images tree structure. The tool expects a particular directory format in order to work properly. Bundles should be placed in `/bundles`, and catalogs in `/catalogs`. From these directories the same convention should be followed: folders within `[catalogs|bundles]` are image names i.e. `test-catalog`. Within these folders is where each tag for that image should be placed. What that ends up looking like is: -```bash -$ tree ./testdata/images/ -./testdata/images/ -├── bundles -│   └── test-operator -│   └── v1.0.0 -│ ├── metadata -│       │ └── annotations.yaml -│      └── manifests -│       └── example.yaml -└── catalogs - └── test-catalog -    ├── v1 -    │   └── configs -    │   └── catalog.yaml -    └── v2 -    └── configs -    └── catalog.yaml -``` -The inside of each tag folder will be placed directly into `/` of the built container i.e. `test-catalog:v1` will have `/configs/catalog.yaml`. - -To add a new image or tag for the tool, create the folders required and populate them with the files to be mounted. Bundle images requiring metadata should contain a `metadata` folder with `annotations.yaml`. Example content: -```yaml -annotations: - # Core bundle annotations. - operators.operatorframework.io.bundle.mediatype.v1: registry+v1 - operators.operatorframework.io.bundle.manifests.v1: manifests/ - operators.operatorframework.io.bundle.metadata.v1: metadata/ - operators.operatorframework.io.bundle.package.v1: test - operators.operatorframework.io.bundle.channels.v1: beta - operators.operatorframework.io.metrics.builder: operator-sdk-v1.28.0 - operators.operatorframework.io.metrics.mediatype.v1: metrics+v1 - operators.operatorframework.io.metrics.project_layout: unknown -``` diff --git a/testdata/push/go.mod b/testdata/push/go.mod deleted file mode 100644 index 72bb1b9e86..0000000000 --- a/testdata/push/go.mod +++ /dev/null @@ -1,26 +0,0 @@ -module registry - -go 1.22.5 - -require ( - github.com/google/go-containerregistry v0.20.2 - github.com/spf13/pflag v1.0.5 - gopkg.in/yaml.v2 v2.4.0 -) - -require ( - github.com/containerd/stargz-snapshotter/estargz v0.15.1 // indirect - github.com/docker/cli v27.3.1+incompatible // indirect - github.com/docker/distribution v2.8.3+incompatible // indirect - github.com/docker/docker-credential-helpers v0.8.2 // indirect - github.com/klauspost/compress v1.17.11 // indirect - github.com/kr/pretty v0.3.1 // indirect - github.com/mitchellh/go-homedir v1.1.0 // indirect - github.com/opencontainers/go-digest v1.0.0 // indirect - github.com/opencontainers/image-spec v1.1.0 // indirect - github.com/pkg/errors v0.9.1 // indirect - github.com/sirupsen/logrus v1.9.3 // indirect - github.com/vbatts/tar-split v0.11.6 // indirect - golang.org/x/sync v0.8.0 // indirect - golang.org/x/sys v0.26.0 // indirect -) diff --git a/testdata/push/go.sum b/testdata/push/go.sum deleted file mode 100644 index 6f7cce0f87..0000000000 --- a/testdata/push/go.sum +++ /dev/null @@ -1,60 +0,0 @@ -github.com/containerd/stargz-snapshotter/estargz v0.15.1 h1:eXJjw9RbkLFgioVaTG+G/ZW/0kEe2oEKCdS/ZxIyoCU= -github.com/containerd/stargz-snapshotter/estargz v0.15.1/go.mod h1:gr2RNwukQ/S9Nv33Lt6UC7xEx58C+LHRdoqbEKjz1Kk= -github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/docker/cli v27.3.1+incompatible h1:qEGdFBF3Xu6SCvCYhc7CzaQTlBmqDuzxPDpigSyeKQQ= -github.com/docker/cli v27.3.1+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8= -github.com/docker/distribution v2.8.3+incompatible h1:AtKxIZ36LoNK51+Z6RpzLpddBirtxJnzDrHLEKxTAYk= -github.com/docker/distribution v2.8.3+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w= -github.com/docker/docker-credential-helpers v0.8.2 h1:bX3YxiGzFP5sOXWc3bTPEXdEaZSeVMrFgOr3T+zrFAo= -github.com/docker/docker-credential-helpers v0.8.2/go.mod h1:P3ci7E3lwkZg6XiHdRKft1KckHiO9a2rNtyFbZ/ry9M= -github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= -github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/go-containerregistry v0.20.2 h1:B1wPJ1SN/S7pB+ZAimcciVD+r+yV/l/DSArMxlbwseo= -github.com/google/go-containerregistry v0.20.2/go.mod h1:z38EKdKh4h7IP2gSfUUqEvalZBqs6AoLeWfUy34nQC8= -github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc= -github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y= -github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= -github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= -github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= -github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug= -github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM= -github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= -github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= -github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= -github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= -github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= -github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= -github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= -github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= -github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= -github.com/vbatts/tar-split v0.11.6 h1:4SjTW5+PU11n6fZenf2IPoV8/tz3AaYHMWjf23envGs= -github.com/vbatts/tar-split v0.11.6/go.mod h1:dqKNtesIOr2j2Qv3W/cHjnvk9I8+G7oAkFDFN6TCBEI= -golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ= -golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= -golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo= -golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= -gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gotest.tools/v3 v3.0.3 h1:4AuOwCGf4lLR9u3YOe2awrHygurzhO/HeQ6laiA6Sx0= -gotest.tools/v3 v3.0.3/go.mod h1:Z7Lb0S5l+klDB31fvDQX8ss/FlKDxtlFlw3Oa8Ymbl8= diff --git a/testdata/push/push.go b/testdata/push/push.go index 13a029eda4..d14876d44e 100644 --- a/testdata/push/push.go +++ b/testdata/push/push.go @@ -1,182 +1,5 @@ +// No-op: test registry images are now built and pushed dynamically by Go test code. +// This stub exists for backward compatibility with downstream CI. package main -import ( - "flag" - "fmt" - "io/fs" - "log" - "os" - "strings" - - "github.com/google/go-containerregistry/pkg/crane" - v1 "github.com/google/go-containerregistry/pkg/v1" - "github.com/google/go-containerregistry/pkg/v1/mutate" - "github.com/spf13/pflag" - "gopkg.in/yaml.v2" -) - -const ( - bundlesSubPath string = "bundles" - catalogsSubPath string = "catalogs" -) - -func main() { - var ( - registryAddr string - imagesPath string - ) - flag.StringVar(®istryAddr, "registry-address", ":12345", "The address the registry binds to.") - flag.StringVar(&imagesPath, "images-path", "/images", "Image directory path") - pflag.CommandLine.AddGoFlagSet(flag.CommandLine) - pflag.Parse() - - log.Printf("push operation configured with images path %s and destination %s", imagesPath, registryAddr) - - bundlesFullPath := fmt.Sprintf("%s/%s", imagesPath, bundlesSubPath) - catalogsFullPath := fmt.Sprintf("%s/%s", imagesPath, catalogsSubPath) - - bundles, err := buildBundles(bundlesFullPath) - if err != nil { - log.Fatalf("failed to build bundles: %s", err.Error()) - } - catalogs, err := buildCatalogs(catalogsFullPath) - if err != nil { - log.Fatalf("failed to build catalogs: %s", err.Error()) - } - // Push the images - for name, image := range bundles { - dest := fmt.Sprintf("%s/%s", registryAddr, name) - log.Printf("pushing bundle %s to %s", name, dest) - if err := crane.Push(image, dest); err != nil { - log.Fatalf("failed to push bundle images: %s", err.Error()) - } - } - for name, image := range catalogs { - dest := fmt.Sprintf("%s/%s", registryAddr, name) - log.Printf("pushing catalog %s to %s", name, dest) - if err := crane.Push(image, fmt.Sprintf("%s/%s", registryAddr, name)); err != nil { - log.Fatalf("failed to push catalog images: %s", err.Error()) - } - } - log.Printf("finished") - os.Exit(0) -} - -func buildBundles(path string) (map[string]v1.Image, error) { - bundles, err := processImageDirTree(path) - if err != nil { - return nil, err - } - mutatedMap := make(map[string]v1.Image, 0) - // Apply required bundle labels - for key, img := range bundles { - // Replace ':' between image name and image tag for file path - metadataPath := strings.Replace(key, ":", "/", 1) - labels, err := getBundleLabels(fmt.Sprintf("%s/%s/%s", path, metadataPath, "metadata/annotations.yaml")) - if err != nil { - return nil, err - } - mutatedMap[fmt.Sprintf("bundles/registry-v1/%s", key)], err = mutate.Config(img, v1.Config{Labels: labels}) - if err != nil { - return nil, fmt.Errorf("failed to apply image labels: %w", err) - } - } - return mutatedMap, nil -} - -type bundleAnnotations struct { - annotations map[string]string -} - -func getBundleLabels(path string) (map[string]string, error) { - var metadata bundleAnnotations - yamlFile, err := os.ReadFile(path) - if err != nil { - return nil, err - } - err = yaml.Unmarshal(yamlFile, metadata) - if err != nil { - return nil, err - } - return metadata.annotations, nil -} - -func buildCatalogs(path string) (map[string]v1.Image, error) { - catalogs, err := processImageDirTree(path) - if err != nil { - return nil, err - } - mutatedMap := make(map[string]v1.Image, 0) - // Apply required catalog label - for key, img := range catalogs { - cfg := v1.Config{ - Labels: map[string]string{ - "operators.operatorframework.io.index.configs.v1": "/configs", - }, - } - mutatedMap[fmt.Sprintf("e2e/%s", key)], err = mutate.Config(img, cfg) - if err != nil { - return nil, fmt.Errorf("failed to apply image labels: %w", err) - } - } - return mutatedMap, nil -} - -func processImageDirTree(path string) (map[string]v1.Image, error) { - imageMap := make(map[string]v1.Image, 0) - images, err := os.ReadDir(path) - if err != nil { - return nil, err - } - - // Each directory in 'path' represents an image - for _, entry := range images { - entryFullPath := fmt.Sprintf("%s/%s", path, entry.Name()) - if !entry.IsDir() { - continue - } - tags, err := os.ReadDir(entryFullPath) - if err != nil { - return nil, err - } - // Each directory in the image directory represents a separate tag - for _, tag := range tags { - if !tag.IsDir() { - continue - } - tagFullPath := fmt.Sprintf("%s/%s", entryFullPath, tag.Name()) - - var fileMap map[string][]byte - fileMap, err = createFileMap(tagFullPath) - if err != nil { - return nil, fmt.Errorf("failed to read files for image: %w", err) - } - - image, err := crane.Image(fileMap) - if err != nil { - return nil, fmt.Errorf("failed to generate image: %w", err) - } - imageMap[fmt.Sprintf("%s:%s", entry.Name(), tag.Name())] = image - } - } - return imageMap, nil -} - -func createFileMap(originPath string) (map[string][]byte, error) { - fileMap := make(map[string][]byte) - if err := fs.WalkDir(os.DirFS(originPath), ".", func(path string, d fs.DirEntry, err error) error { - if err != nil { - return err - } - if d != nil && !d.IsDir() { - fileMap[path], err = os.ReadFile(fmt.Sprintf("%s/%s", originPath, path)) - if err != nil { - return err - } - } - return nil - }); err != nil { - return nil, err - } - return fileMap, nil -} +func main() {}