Repository: operator-framework/operator-lifecycle-manager
Pull request #2330 (2021-08-18 16:58:26)

Prune API of the resolver package.
The resolver package exports a number of identifiers that have not been used for resolution in over a year. As part of the ongoing effort to decouple purely-resolution-related concerns from the rest of OLM, some of these have been rehomed into the packages that still consume them, and entirely unused code has been removed.

openshift-ci[bot]: [APPROVALNOTIFIER] This PR is **APPROVED**

This pull-request has been approved by: *<a href="https://github.com/operator-framework/operator-lifecycle-manager/pull/2330#" title="Author self-approved">benluddy</a>*

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=operator-framework%2Foperator-lifecycle-manager).

The pull request process is described [here](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process)

<details >
Needs approval from an approver in each of these files:

- ~~[OWNERS](https://github.com/operator-framework/operator-lifecycle-manager/blob/master/OWNERS)~~ [benluddy]

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":[]} -->
openshift-ci[bot]: [APPROVALNOTIFIER] This PR is **APPROVED**

This pull-request has been approved by: *<a href="https://github.com/operator-framework/operator-lifecycle-manager/pull/2330#" title="Author self-approved">benluddy</a>*, *<a href="https://github.com/operator-framework/operator-lifecycle-manager/pull/2330#pullrequestreview-733167773" title="LGTM">njhale</a>*

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=operator-framework%2Foperator-lifecycle-manager).

The pull request process is described [here](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process)

<details >
Needs approval from an approver in each of these files:

- ~~[OWNERS](https://github.com/operator-framework/operator-lifecycle-manager/blob/master/OWNERS)~~ [benluddy,njhale]

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":[]} -->
openshift-ci[bot]: [APPROVALNOTIFIER] This PR is **APPROVED**

This pull-request has been approved by: *<a href="https://github.com/operator-framework/operator-lifecycle-manager/pull/2330#" title="Author self-approved">benluddy</a>*, *<a href="https://github.com/operator-framework/operator-lifecycle-manager/pull/2330#pullrequestreview-733189096" title="LGTM">dinhxuanvu</a>*, *<a href="https://github.com/operator-framework/operator-lifecycle-manager/pull/2330#pullrequestreview-733167773" title="LGTM">njhale</a>*

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=operator-framework%2Foperator-lifecycle-manager).

The pull request process is described [here](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process)

<details >
Needs approval from an approver in each of these files:

- ~~[OWNERS](https://github.com/operator-framework/operator-lifecycle-manager/blob/master/OWNERS)~~ [benluddy,njhale]

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":[]} -->

Patch:
diff --git a/pkg/controller/registry/resolver/fakes/fake_registry_client.go b/pkg/controller/operators/catalog/fakes/fake_registry_client.go
similarity index 100%
rename from pkg/controller/registry/resolver/fakes/fake_registry_client.go
rename to pkg/controller/operators/catalog/fakes/fake_registry_client.go
diff --git a/pkg/controller/registry/resolver/fakes/fake_registry_client_interface.go b/pkg/controller/operators/catalog/fakes/fake_registry_interface.go
similarity index 100%
rename from pkg/controller/registry/resolver/fakes/fake_registry_client_interface.go
rename to pkg/controller/operators/catalog/fakes/fake_registry_interface.go
diff --git a/pkg/controller/operators/catalog/operator.go b/pkg/controller/operators/catalog/operator.go
index 6e44cc393..cc1b6922e 100644
--- a/pkg/controller/operators/catalog/operator.go
+++ b/pkg/controller/operators/catalog/operator.go
@@ -890,7 +890,7 @@ func (o *Operator) syncResolvingNamespace(obj interface{}) error {
 	// get the set of sources that should be used for resolution and best-effort get their connections working
 	logger.Debug("resolving sources")
 
-	querier := resolver.NewNamespaceSourceQuerier(o.sources.AsClients(o.namespace, namespace))
+	querier := NewNamespaceSourceQuerier(o.sources.AsClients(o.namespace, namespace))
 
 	logger.Debug("checking if subscriptions need update")
 
@@ -950,7 +950,7 @@ func (o *Operator) syncResolvingNamespace(obj interface{}) error {
 	logger.Debug("resolving subscriptions in namespace")
 
 	// resolve a set of steps to apply to a cluster, a set of subscriptions to create/update, and any errors
-	steps, bundleLookups, updatedSubs, err := o.resolver.ResolveSteps(namespace, querier)
+	steps, bundleLookups, updatedSubs, err := o.resolver.ResolveSteps(namespace)
 	if err != nil {
 		go o.recorder.Event(ns, corev1.EventTypeWarning, "ResolutionFailed", err.Error())
 		// If the error is constraints not satisfiable, then simply project the
@@ -1085,7 +1085,7 @@ func (o *Operator) ensureSubscriptionInstallPlanState(logger *logrus.Entry, sub
 	return updated, true, nil
 }
 
-func (o *Operator) ensureSubscriptionCSVState(logger *logrus.Entry, sub *v1alpha1.Subscription, querier resolver.SourceQuerier) (*v1alpha1.Subscription, bool, error) {
+func (o *Operator) ensureSubscriptionCSVState(logger *logrus.Entry, sub *v1alpha1.Subscription, querier SourceQuerier) (*v1alpha1.Subscription, bool, error) {
 	if sub.Status.CurrentCSV == "" {
 		return sub, false, nil
 	}
diff --git a/pkg/controller/operators/catalog/querier.go b/pkg/controller/operators/catalog/querier.go
new file mode 100644
index 000000000..1faf2c05c
--- /dev/null
+++ b/pkg/controller/operators/catalog/querier.go
@@ -0,0 +1,123 @@
+//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -o fakes/fake_registry_client.go ../../../../vendor/github.com/operator-framework/operator-registry/pkg/api.RegistryClient
+//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -o fakes/fake_registry_interface.go ../../registry/registry_client.go ClientInterface
+package catalog
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/blang/semver/v4"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/errors"
+
+	"github.com/operator-framework/operator-registry/pkg/api"
+	"github.com/operator-framework/operator-registry/pkg/client"
+
+	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry"
+)
+
+const SkipPackageAnnotationKey = "olm.skipRange"
+
+type SourceRef struct {
+	Address     string
+	Client      client.Interface
+	LastConnect metav1.Time
+	LastHealthy metav1.Time
+}
+
+type SourceQuerier interface {
+	FindReplacement(currentVersion *semver.Version, bundleName, pkgName, channelName string, initialSource registry.CatalogKey) (*api.Bundle, *registry.CatalogKey, error)
+	Queryable() error
+}
+
+type NamespaceSourceQuerier struct {
+	sources map[registry.CatalogKey]registry.ClientInterface
+}
+
+var _ SourceQuerier = &NamespaceSourceQuerier{}
+
+func NewNamespaceSourceQuerier(sources map[registry.CatalogKey]registry.ClientInterface) *NamespaceSourceQuerier {
+	return &NamespaceSourceQuerier{
+		sources: sources,
+	}
+}
+
+func (q *NamespaceSourceQuerier) Queryable() error {
+	if len(q.sources) == 0 {
+		return fmt.Errorf("no catalog sources available")
+	}
+	return nil
+}
+
+func (q *NamespaceSourceQuerier) FindReplacement(currentVersion *semver.Version, bundleName, pkgName, channelName string, initialSource registry.CatalogKey) (*api.Bundle, *registry.CatalogKey, error) {
+	errs := []error{}
+
+	if initialSource.Name != "" && initialSource.Namespace != "" {
+		source, ok := q.sources[initialSource]
+		if !ok {
+			return nil, nil, fmt.Errorf("CatalogSource %s not found", initialSource.Name)
+		}
+
+		bundle, err := q.findChannelHead(currentVersion, pkgName, channelName, source)
+		if bundle != nil {
+			return bundle, &initialSource, nil
+		}
+		if err != nil {
+			errs = append(errs, err)
+		}
+
+		bundle, err = source.GetReplacementBundleInPackageChannel(context.TODO(), bundleName, pkgName, channelName)
+		if bundle != nil {
+			return bundle, &initialSource, nil
+		}
+		if err != nil {
+			errs = append(errs, err)
+		}
+
+		return nil, nil, errors.NewAggregate(errs)
+	}
+
+	for key, source := range q.sources {
+		bundle, err := q.findChannelHead(currentVersion, pkgName, channelName, source)
+		if bundle != nil {
+			return bundle, &initialSource, nil
+		}
+		if err != nil {
+			errs = append(errs, err)
+		}
+
+		bundle, err = source.GetReplacementBundleInPackageChannel(context.TODO(), bundleName, pkgName, channelName)
+		if bundle != nil {
+			return bundle, &key, nil
+		}
+		if err != nil {
+			errs = append(errs, err)
+		}
+	}
+	return nil, nil, errors.NewAggregate(errs)
+}
+
+func (q *NamespaceSourceQuerier) findChannelHead(currentVersion *semver.Version, pkgName, channelName string, source client.Interface) (*api.Bundle, error) {
+	if currentVersion == nil {
+		return nil, nil
+	}
+
+	latest, err := source.GetBundleInPackageChannel(context.TODO(), pkgName, channelName)
+	if err != nil {
+		return nil, err
+	}
+
+	if latest.SkipRange == "" {
+		return nil, nil
+	}
+
+	r, err := semver.ParseRange(latest.SkipRange)
+	if err != nil {
+		return nil, err
+	}
+
+	if r(*currentVersion) {
+		return latest, nil
+	}
+	return nil, nil
+}
diff --git a/pkg/controller/operators/olm/config.go b/pkg/controller/operators/olm/config.go
index 69f156ecf..98ac5ff95 100644
--- a/pkg/controller/operators/olm/config.go
+++ b/pkg/controller/operators/olm/config.go
@@ -14,7 +14,6 @@ import (
 	configv1client "github.com/openshift/client-go/config/clientset/versioned"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install"
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/lib/labeler"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorclient"
 )
@@ -30,7 +29,7 @@ type operatorConfig struct {
 	operatorClient    operatorclient.ClientInterface
 	externalClient    versioned.Interface
 	strategyResolver  install.StrategyResolverInterface
-	apiReconciler     resolver.APIIntersectionReconciler
+	apiReconciler     APIIntersectionReconciler
 	apiLabeler        labeler.Labeler
 	restConfig        *rest.Config
 	configClient      configv1client.Interface
@@ -84,8 +83,8 @@ func defaultOperatorConfig() *operatorConfig {
 		clock:             utilclock.RealClock{},
 		logger:            logrus.New(),
 		strategyResolver:  &install.StrategyResolver{},
-		apiReconciler:     resolver.APIIntersectionReconcileFunc(resolver.ReconcileAPIIntersection),
-		apiLabeler:        labeler.Func(resolver.LabelSetsFor),
+		apiReconciler:     APIIntersectionReconcileFunc(ReconcileAPIIntersection),
+		apiLabeler:        labeler.Func(LabelSetsFor),
 	}
 }
 
@@ -137,7 +136,7 @@ func WithStrategyResolver(strategyResolver install.StrategyResolverInterface) Op
 	}
 }
 
-func WithAPIReconciler(apiReconciler resolver.APIIntersectionReconciler) OperatorOption {
+func WithAPIReconciler(apiReconciler APIIntersectionReconciler) OperatorOption {
 	return func(config *operatorConfig) {
 		config.apiReconciler = apiReconciler
 	}
diff --git a/pkg/controller/registry/resolver/groups.go b/pkg/controller/operators/olm/groups.go
similarity index 96%
rename from pkg/controller/registry/resolver/groups.go
rename to pkg/controller/operators/olm/groups.go
index 72f3e68eb..90481c5f4 100644
--- a/pkg/controller/registry/resolver/groups.go
+++ b/pkg/controller/operators/olm/groups.go
@@ -1,5 +1,4 @@
-//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -o ../../../fakes/fake_api_intersection_reconciler.go . APIIntersectionReconciler
-package resolver
+package olm
 
 import (
 	"strings"
diff --git a/pkg/controller/registry/resolver/labeler.go b/pkg/controller/operators/olm/labeler.go
similarity index 61%
rename from pkg/controller/registry/resolver/labeler.go
rename to pkg/controller/operators/olm/labeler.go
index 9b10eb2d6..c0d003da5 100644
--- a/pkg/controller/registry/resolver/labeler.go
+++ b/pkg/controller/operators/olm/labeler.go
@@ -1,8 +1,9 @@
-package resolver
+package olm
 
 import (
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache"
 	"github.com/operator-framework/operator-registry/pkg/registry"
+	extv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	extv1beta1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
 	"k8s.io/apimachinery/pkg/labels"
 )
@@ -12,20 +13,27 @@ const (
 	APILabelKeyPrefix = "olm.api."
 )
 
+type operatorSurface interface {
+	GetProvidedAPIs() cache.APISet
+	GetRequiredAPIs() cache.APISet
+}
+
 // LabelSetsFor returns API label sets for the given object.
 // Concrete types other than OperatorSurface and CustomResource definition no-op.
 func LabelSetsFor(obj interface{}) ([]labels.Set, error) {
 	switch v := obj.(type) {
-	case cache.OperatorSurface:
+	case operatorSurface:
 		return labelSetsForOperatorSurface(v)
 	case *extv1beta1.CustomResourceDefinition:
-		return labelSetsForCRD(v)
+		return labelSetsForCRDv1beta1(v)
+	case *extv1.CustomResourceDefinition:
+		return labelSetsForCRDv1(v)
 	default:
 		return nil, nil
 	}
 }
 
-func labelSetsForOperatorSurface(surface cache.OperatorSurface) ([]labels.Set, error) {
+func labelSetsForOperatorSurface(surface operatorSurface) ([]labels.Set, error) {
 	labelSet := labels.Set{}
 	for key := range surface.GetProvidedAPIs().StripPlural() {
 		hash, err := cache.APIKeyToGVKHash(key)
@@ -45,7 +53,38 @@ func labelSetsForOperatorSurface(surface cache.OperatorSurface) ([]labels.Set, e
 	return []labels.Set{labelSet}, nil
 }
 
-func labelSetsForCRD(crd *extv1beta1.CustomResourceDefinition) ([]labels.Set, error) {
+func labelSetsForCRDv1beta1(crd *extv1beta1.CustomResourceDefinition) ([]labels.Set, error) {
+	labelSets := []labels.Set{}
+	if crd == nil {
+		return labelSets, nil
+	}
+
+	// Add label sets for each version
+	for _, version := range crd.Spec.Versions {
+		hash, err := cache.APIKeyToGVKHash(registry.APIKey{
+			Group:   crd.Spec.Group,
+			Version: version.Name,
+			Kind:    crd.Spec.Names.Kind,
+		})
+		if err != nil {
+			return nil, err
+		}
+		key := APILabelKeyPrefix + hash
+		sets := []labels.Set{
+			{
+				key: "provided",
+			},
+			{
+				key: "required",
+			},
+		}
+		labelSets = append(labelSets, sets...)
+	}
+
+	return labelSets, nil
+}
+
+func labelSetsForCRDv1(crd *extv1.CustomResourceDefinition) ([]labels.Set, error) {
 	labelSets := []labels.Set{}
 	if crd == nil {
 		return labelSets, nil
diff --git a/pkg/controller/operators/olm/operator.go b/pkg/controller/operators/olm/operator.go
index b71abe211..39018ee37 100644
--- a/pkg/controller/operators/olm/operator.go
+++ b/pkg/controller/operators/olm/operator.go
@@ -37,7 +37,6 @@ import (
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/internal/pruning"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/overrides"
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver"
 	resolvercache "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/lib/clients"
 	csvutility "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/csv"
@@ -79,7 +78,7 @@ type Operator struct {
 	csvIndexers           map[string]cache.Indexer
 	recorder              record.EventRecorder
 	resolver              install.StrategyResolverInterface
-	apiReconciler         resolver.APIIntersectionReconciler
+	apiReconciler         APIIntersectionReconciler
 	apiLabeler            labeler.Labeler
 	csvSetGenerator       csvutility.SetGenerator
 	csvReplaceFinder      csvutility.ReplaceFinder
@@ -846,7 +845,7 @@ func (a *Operator) namespaceAddedOrRemoved(obj interface{}) {
 	}
 
 	for _, group := range operatorGroupList {
-		if resolver.NewNamespaceSet(group.Status.Namespaces).Contains(namespace.GetName()) {
+		if NewNamespaceSet(group.Status.Namespaces).Contains(namespace.GetName()) {
 			if err := a.ogQueueSet.Requeue(group.Namespace, group.Name); err != nil {
 				logger.WithError(err).Warn("error requeuing operatorgroup")
 			}
@@ -881,7 +880,7 @@ func (a *Operator) syncNamespace(obj interface{}) error {
 	}
 
 	for _, group := range operatorGroupList {
-		namespaceSet := resolver.NewNamespaceSet(group.Status.Namespaces)
+		namespaceSet := NewNamespaceSet(group.Status.Namespaces)
 
 		// Apply the label if not an All Namespaces OperatorGroup.
 		if namespaceSet.Contains(namespace.GetName()) && !namespaceSet.IsAllNamespaces() {
@@ -1098,7 +1097,7 @@ func (a *Operator) removeDanglingChildCSVs(csv *v1alpha1.ClusterServiceVersion)
 	}
 
 	if annotations := parent.GetAnnotations(); annotations != nil {
-		if !resolver.NewNamespaceSetFromString(annotations[v1.OperatorGroupTargetsAnnotationKey]).Contains(csv.GetNamespace()) {
+		if !NewNamespaceSetFromString(annotations[v1.OperatorGroupTargetsAnnotationKey]).Contains(csv.GetNamespace()) {
 			logger.WithField("parentTargets", annotations[v1.OperatorGroupTargetsAnnotationKey]).
 				Debug("deleting copied CSV since parent no longer lists this as a target namespace")
 			return a.deleteChild(csv, logger)
@@ -1226,7 +1225,7 @@ func (a *Operator) syncCopyCSV(obj interface{}) (syncError error) {
 	}).Debug("copying csv to targets")
 
 	// Check if we need to do any copying / annotation for the operatorgroup
-	if err := a.ensureCSVsInNamespaces(clusterServiceVersion, operatorGroup, resolver.NewNamespaceSet(operatorGroup.Status.Namespaces)); err != nil {
+	if err := a.ensureCSVsInNamespaces(clusterServiceVersion, operatorGroup, NewNamespaceSet(operatorGroup.Status.Namespaces)); err != nil {
 		logger.WithError(err).Info("couldn't copy CSV to target namespaces")
 		syncError = err
 	}
@@ -1427,12 +1426,12 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 		}
 	}
 
-	groupSurface := resolver.NewOperatorGroup(operatorGroup)
-	otherGroupSurfaces := resolver.NewOperatorGroupSurfaces(otherGroups...)
+	groupSurface := NewOperatorGroup(operatorGroup)
+	otherGroupSurfaces := NewOperatorGroupSurfaces(otherGroups...)
 	providedAPIs := operatorSurface.GetProvidedAPIs().StripPlural()
 
 	switch result := a.apiReconciler.Reconcile(providedAPIs, groupSurface, otherGroupSurfaces...); {
-	case operatorGroup.Spec.StaticProvidedAPIs && (result == resolver.AddAPIs || result == resolver.RemoveAPIs):
+	case operatorGroup.Spec.StaticProvidedAPIs && (result == AddAPIs || result == RemoveAPIs):
 		// Transition the CSV to FAILED with status reason "CannotModifyStaticOperatorGroupProvidedAPIs"
 		if out.Status.Reason != v1alpha1.CSVReasonInterOperatorGroupOwnerConflict {
 			logger.WithField("apis", providedAPIs).Warn("cannot modify provided apis of static provided api operatorgroup")
@@ -1440,7 +1439,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 			a.cleanupCSVDeployments(logger, out)
 		}
 		return
-	case result == resolver.APIConflict:
+	case result == APIConflict:
 		// Transition the CSV to FAILED with status reason "InterOperatorGroupOwnerConflict"
 		if out.Status.Reason != v1alpha1.CSVReasonInterOperatorGroupOwnerConflict {
 			logger.WithField("apis", providedAPIs).Warn("intersecting operatorgroups provide the same apis")
@@ -1448,7 +1447,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 			a.cleanupCSVDeployments(logger, out)
 		}
 		return
-	case result == resolver.AddAPIs:
+	case result == AddAPIs:
 		// Add the CSV's provided APIs to its OperatorGroup's annotation
 		logger.WithField("apis", providedAPIs).Debug("adding csv provided apis to operatorgroup")
 		union := groupSurface.ProvidedAPIs().Union(providedAPIs)
@@ -1471,7 +1470,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 			a.logger.WithError(err).Warn("unable to requeue")
 		}
 		return
-	case result == resolver.RemoveAPIs:
+	case result == RemoveAPIs:
 		// Remove the CSV's provided APIs from its OperatorGroup's annotation
 		logger.WithField("apis", providedAPIs).Debug("removing csv provided apis from operatorgroup")
 		difference := groupSurface.ProvidedAPIs().Difference(providedAPIs)
diff --git a/pkg/controller/operators/olm/operatorgroup.go b/pkg/controller/operators/olm/operatorgroup.go
index 8c28ef0d1..8a2871a31 100644
--- a/pkg/controller/operators/olm/operatorgroup.go
+++ b/pkg/controller/operators/olm/operatorgroup.go
@@ -21,7 +21,6 @@ import (
 	"github.com/operator-framework/api/pkg/operators/v1alpha1"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/decorators"
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache"
 	hashutil "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/kubernetes/pkg/util/hash"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/lib/ownerutil"
@@ -186,7 +185,7 @@ func (a *Operator) syncOperatorGroups(obj interface{}) error {
 	// Requeue all CSVs that provide the same APIs (including those removed). This notifies conflicting CSVs in
 	// intersecting groups that their conflict has possibly been resolved, either through resizing or through
 	// deletion of the conflicting CSV.
-	groupSurface := resolver.NewOperatorGroup(op)
+	groupSurface := NewOperatorGroup(op)
 	groupProvidedAPIs := groupSurface.ProvidedAPIs()
 	providedAPIsForCSVs := a.providedAPIsFromCSVs(op, logger)
 	providedAPIsForGroup := make(cache.APISet)
@@ -255,7 +254,7 @@ func (a *Operator) operatorGroupDeleted(obj interface{}) {
 
 func (a *Operator) annotateCSVs(group *v1.OperatorGroup, targetNamespaces []string, logger *logrus.Entry) error {
 	updateErrs := []error{}
-	targetNamespaceSet := resolver.NewNamespaceSet(targetNamespaces)
+	targetNamespaceSet := NewNamespaceSet(targetNamespaces)
 
 	for _, csv := range a.csvSet(group.GetNamespace(), v1alpha1.CSVPhaseAny) {
 		if csv.IsCopied() {
@@ -264,7 +263,7 @@ func (a *Operator) annotateCSVs(group *v1.OperatorGroup, targetNamespaces []stri
 		logger := logger.WithField("csv", csv.GetName())
 
 		originalNamespacesAnnotation, _ := a.copyOperatorGroupAnnotations(&csv.ObjectMeta)[v1.OperatorGroupTargetsAnnotationKey]
-		originalNamespaceSet := resolver.NewNamespaceSetFromString(originalNamespacesAnnotation)
+		originalNamespaceSet := NewNamespaceSetFromString(originalNamespacesAnnotation)
 
 		if a.operatorGroupAnnotationsDiffer(&csv.ObjectMeta, group) {
 			a.setOperatorGroupAnnotations(&csv.ObjectMeta, group, true)
@@ -689,7 +688,7 @@ func (a *Operator) ensureTenantRBAC(operatorNamespace, targetNamespace string, c
 	return nil
 }
 
-func (a *Operator) ensureCSVsInNamespaces(csv *v1alpha1.ClusterServiceVersion, operatorGroup *v1.OperatorGroup, targets resolver.NamespaceSet) error {
+func (a *Operator) ensureCSVsInNamespaces(csv *v1alpha1.ClusterServiceVersion, operatorGroup *v1.OperatorGroup, targets NamespaceSet) error {
 	namespaces, err := a.lister.CoreV1().NamespaceLister().List(labels.Everything())
 	if err != nil {
 		return err
diff --git a/pkg/controller/registry/resolver/cache/operators.go b/pkg/controller/registry/resolver/cache/operators.go
index 7b8512413..1df76b270 100644
--- a/pkg/controller/registry/resolver/cache/operators.go
+++ b/pkg/controller/registry/resolver/cache/operators.go
@@ -137,21 +137,21 @@ func (s APISet) StripPlural() APISet {
 	return set
 }
 
-type APIOwnerSet map[opregistry.APIKey]OperatorSurface
+type APIOwnerSet map[opregistry.APIKey]*Operator
 
 func EmptyAPIOwnerSet() APIOwnerSet {
-	return map[opregistry.APIKey]OperatorSurface{}
+	return map[opregistry.APIKey]*Operator{}
 }
 
-type OperatorSet map[string]OperatorSurface
+type OperatorSet map[string]*Operator
 
 func EmptyOperatorSet() OperatorSet {
-	return map[string]OperatorSurface{}
+	return map[string]*Operator{}
 }
 
 // Snapshot returns a new set, pointing to the same values
 func (o OperatorSet) Snapshot() OperatorSet {
-	out := make(map[string]OperatorSurface)
+	out := make(map[string]*Operator)
 	for key, val := range o {
 		out[key] = val
 	}
@@ -206,34 +206,19 @@ func (i *OperatorSourceInfo) String() string {
 var NoCatalog = registry.CatalogKey{Name: "", Namespace: ""}
 var ExistingOperator = OperatorSourceInfo{Package: "", Channel: "", StartingCSV: "", Catalog: NoCatalog, DefaultChannel: false}
 
-// OperatorSurface describes the API surfaces provided and required by an Operator.
-type OperatorSurface interface {
-	GetProvidedAPIs() APISet
-	GetRequiredAPIs() APISet
-	Identifier() string
-	GetReplaces() string
-	GetVersion() *semver.Version
-	GetSourceInfo() *OperatorSourceInfo
-	GetBundle() *api.Bundle
-	Inline() bool
-	GetProperties() []*api.Property
-	GetSkips() []string
-}
-
 type Operator struct {
 	Name         string
 	Replaces     string
+	Skips        []string
+	SkipRange    semver.Range
 	ProvidedAPIs APISet
 	RequiredAPIs APISet
 	Version      *semver.Version
 	Bundle       *api.Bundle
 	SourceInfo   *OperatorSourceInfo
 	Properties   []*api.Property
-	Skips        []string
 }
 
-var _ OperatorSurface = &Operator{}
-
 func NewOperatorFromBundle(bundle *api.Bundle, startingCSV string, sourceKey registry.CatalogKey, defaultChannel string) (*Operator, error) {
 	parsedVersion, err := semver.ParseTolerant(bundle.Version)
 	version := &parsedVersion
@@ -290,6 +275,10 @@ func NewOperatorFromBundle(bundle *api.Bundle, startingCSV string, sourceKey reg
 		Skips:        bundle.Skips,
 	}
 
+	if r, err := semver.ParseRange(o.Bundle.SkipRange); err == nil {
+		o.SkipRange = r
+	}
+
 	if !o.Inline() {
 		// TODO: Extract any necessary information from the Bundle
 		// up-front and remove the bundle field altogether. For now,
@@ -355,18 +344,6 @@ func (o *Operator) GetRequiredAPIs() APISet {
 	return o.RequiredAPIs
 }
 
-func (o *Operator) Identifier() string {
-	return o.Name
-}
-
-func (o *Operator) GetReplaces() string {
-	return o.Replaces
-}
-
-func (o *Operator) GetSkips() []string {
-	return o.Skips
-}
-
 func (o *Operator) Package() string {
 	if o.Bundle != nil {
 		return o.Bundle.PackageName
@@ -381,30 +358,10 @@ func (o *Operator) Channel() string {
 	return ""
 }
 
-func (o *Operator) GetSourceInfo() *OperatorSourceInfo {
-	return o.SourceInfo
-}
-
-func (o *Operator) GetBundle() *api.Bundle {
-	return o.Bundle
-}
-
-func (o *Operator) GetVersion() *semver.Version {
-	return o.Version
-}
-
-func (o *Operator) SemverRange() (semver.Range, error) {
-	return semver.ParseRange(o.Bundle.SkipRange)
-}
-
 func (o *Operator) Inline() bool {
 	return o.Bundle != nil && o.Bundle.GetBundlePath() == ""
 }
 
-func (o *Operator) GetProperties() []*api.Property {
-	return o.Properties
-}
-
 func (o *Operator) DependencyPredicates() (predicates []OperatorPredicate, err error) {
 	predicates = make([]OperatorPredicate, 0)
 	for _, property := range o.Properties {
diff --git a/pkg/controller/registry/resolver/cache/predicates.go b/pkg/controller/registry/resolver/cache/predicates.go
index 171ee5ac9..7e8649d5d 100644
--- a/pkg/controller/registry/resolver/cache/predicates.go
+++ b/pkg/controller/registry/resolver/cache/predicates.go
@@ -195,8 +195,7 @@ func SkipRangeIncludesPredicate(version semver.Version) OperatorPredicate {
 }
 
 func (s skipRangeIncludesPredication) Test(o *Operator) bool {
-	semverRange, err := o.SemverRange()
-	return err == nil && semverRange(s.version)
+	return o.SkipRange != nil && o.SkipRange(s.version)
 }
 
 func (s skipRangeIncludesPredication) String() string {
diff --git a/pkg/controller/registry/resolver/fakes/fake_registry_interface.go b/pkg/controller/registry/resolver/fakes/fake_registry_interface.go
deleted file mode 100644
index c86f56572..000000000
--- a/pkg/controller/registry/resolver/fakes/fake_registry_interface.go
+++ /dev/null
@@ -1,676 +0,0 @@
-// Code generated by counterfeiter. DO NOT EDIT.
-package fakes
-
-import (
-	"context"
-	"sync"
-	"time"
-
-	"github.com/operator-framework/operator-registry/pkg/api"
-	"github.com/operator-framework/operator-registry/pkg/client"
-)
-
-type FakeInterface struct {
-	CloseStub        func() error
-	closeMutex       sync.RWMutex
-	closeArgsForCall []struct {
-	}
-	closeReturns struct {
-		result1 error
-	}
-	closeReturnsOnCall map[int]struct {
-		result1 error
-	}
-	GetBundleStub        func(context.Context, string, string, string) (*api.Bundle, error)
-	getBundleMutex       sync.RWMutex
-	getBundleArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 string
-	}
-	getBundleReturns struct {
-		result1 *api.Bundle
-		result2 error
-	}
-	getBundleReturnsOnCall map[int]struct {
-		result1 *api.Bundle
-		result2 error
-	}
-	GetBundleInPackageChannelStub        func(context.Context, string, string) (*api.Bundle, error)
-	getBundleInPackageChannelMutex       sync.RWMutex
-	getBundleInPackageChannelArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-	}
-	getBundleInPackageChannelReturns struct {
-		result1 *api.Bundle
-		result2 error
-	}
-	getBundleInPackageChannelReturnsOnCall map[int]struct {
-		result1 *api.Bundle
-		result2 error
-	}
-	GetBundleThatProvidesStub        func(context.Context, string, string, string) (*api.Bundle, error)
-	getBundleThatProvidesMutex       sync.RWMutex
-	getBundleThatProvidesArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 string
-	}
-	getBundleThatProvidesReturns struct {
-		result1 *api.Bundle
-		result2 error
-	}
-	getBundleThatProvidesReturnsOnCall map[int]struct {
-		result1 *api.Bundle
-		result2 error
-	}
-	GetPackageStub        func(context.Context, string) (*api.Package, error)
-	getPackageMutex       sync.RWMutex
-	getPackageArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-	}
-	getPackageReturns struct {
-		result1 *api.Package
-		result2 error
-	}
-	getPackageReturnsOnCall map[int]struct {
-		result1 *api.Package
-		result2 error
-	}
-	GetReplacementBundleInPackageChannelStub        func(context.Context, string, string, string) (*api.Bundle, error)
-	getReplacementBundleInPackageChannelMutex       sync.RWMutex
-	getReplacementBundleInPackageChannelArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 string
-	}
-	getReplacementBundleInPackageChannelReturns struct {
-		result1 *api.Bundle
-		result2 error
-	}
-	getReplacementBundleInPackageChannelReturnsOnCall map[int]struct {
-		result1 *api.Bundle
-		result2 error
-	}
-	HealthCheckStub        func(context.Context, time.Duration) (bool, error)
-	healthCheckMutex       sync.RWMutex
-	healthCheckArgsForCall []struct {
-		arg1 context.Context
-		arg2 time.Duration
-	}
-	healthCheckReturns struct {
-		result1 bool
-		result2 error
-	}
-	healthCheckReturnsOnCall map[int]struct {
-		result1 bool
-		result2 error
-	}
-	ListBundlesStub        func(context.Context) (*client.BundleIterator, error)
-	listBundlesMutex       sync.RWMutex
-	listBundlesArgsForCall []struct {
-		arg1 context.Context
-	}
-	listBundlesReturns struct {
-		result1 *client.BundleIterator
-		result2 error
-	}
-	listBundlesReturnsOnCall map[int]struct {
-		result1 *client.BundleIterator
-		result2 error
-	}
-	invocations      map[string][][]interface{}
-	invocationsMutex sync.RWMutex
-}
-
-func (fake *FakeInterface) Close() error {
-	fake.closeMutex.Lock()
-	ret, specificReturn := fake.closeReturnsOnCall[len(fake.closeArgsForCall)]
-	fake.closeArgsForCall = append(fake.closeArgsForCall, struct {
-	}{})
-	fake.recordInvocation("Close", []interface{}{})
-	fake.closeMutex.Unlock()
-	if fake.CloseStub != nil {
-		return fake.CloseStub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	fakeReturns := fake.closeReturns
-	return fakeReturns.result1
-}
-
-func (fake *FakeInterface) CloseCallCount() int {
-	fake.closeMutex.RLock()
-	defer fake.closeMutex.RUnlock()
-	return len(fake.closeArgsForCall)
-}
-
-func (fake *FakeInterface) CloseCalls(stub func() error) {
-	fake.closeMutex.Lock()
-	defer fake.closeMutex.Unlock()
-	fake.CloseStub = stub
-}
-
-func (fake *FakeInterface) CloseReturns(result1 error) {
-	fake.closeMutex.Lock()
-	defer fake.closeMutex.Unlock()
-	fake.CloseStub = nil
-	fake.closeReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeInterface) CloseReturnsOnCall(i int, result1 error) {
-	fake.closeMutex.Lock()
-	defer fake.closeMutex.Unlock()
-	fake.CloseStub = nil
-	if fake.closeReturnsOnCall == nil {
-		fake.closeReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.closeReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeInterface) GetBundle(arg1 context.Context, arg2 string, arg3 string, arg4 string) (*api.Bundle, error) {
-	fake.getBundleMutex.Lock()
-	ret, specificReturn := fake.getBundleReturnsOnCall[len(fake.getBundleArgsForCall)]
-	fake.getBundleArgsForCall = append(fake.getBundleArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 string
-	}{arg1, arg2, arg3, arg4})
-	fake.recordInvocation("GetBundle", []interface{}{arg1, arg2, arg3, arg4})
-	fake.getBundleMutex.Unlock()
-	if fake.GetBundleStub != nil {
-		return fake.GetBundleStub(arg1, arg2, arg3, arg4)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.getBundleReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeInterface) GetBundleCallCount() int {
-	fake.getBundleMutex.RLock()
-	defer fake.getBundleMutex.RUnlock()
-	return len(fake.getBundleArgsForCall)
-}
-
-func (fake *FakeInterface) GetBundleCalls(stub func(context.Context, string, string, string) (*api.Bundle, error)) {
-	fake.getBundleMutex.Lock()
-	defer fake.getBundleMutex.Unlock()
-	fake.GetBundleStub = stub
-}
-
-func (fake *FakeInterface) GetBundleArgsForCall(i int) (context.Context, string, string, string) {
-	fake.getBundleMutex.RLock()
-	defer fake.getBundleMutex.RUnlock()
-	argsForCall := fake.getBundleArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
-}
-
-func (fake *FakeInterface) GetBundleReturns(result1 *api.Bundle, result2 error) {
-	fake.getBundleMutex.Lock()
-	defer fake.getBundleMutex.Unlock()
-	fake.GetBundleStub = nil
-	fake.getBundleReturns = struct {
-		result1 *api.Bundle
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeInterface) GetBundleReturnsOnCall(i int, result1 *api.Bundle, result2 error) {
-	fake.getBundleMutex.Lock()
-	defer fake.getBundleMutex.Unlock()
-	fake.GetBundleStub = nil
-	if fake.getBundleReturnsOnCall == nil {
-		fake.getBundleReturnsOnCall = make(map[int]struct {
-			result1 *api.Bundle
-			result2 error
-		})
-	}
-	fake.getBundleReturnsOnCall[i] = struct {
-		result1 *api.Bundle
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeInterface) GetBundleInPackageChannel(arg1 context.Context, arg2 string, arg3 string) (*api.Bundle, error) {
-	fake.getBundleInPackageChannelMutex.Lock()
-	ret, specificReturn := fake.getBundleInPackageChannelReturnsOnCall[len(fake.getBundleInPackageChannelArgsForCall)]
-	fake.getBundleInPackageChannelArgsForCall = append(fake.getBundleInPackageChannelArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-	}{arg1, arg2, arg3})
-	fake.recordInvocation("GetBundleInPackageChannel", []interface{}{arg1, arg2, arg3})
-	fake.getBundleInPackageChannelMutex.Unlock()
-	if fake.GetBundleInPackageChannelStub != nil {
-		return fake.GetBundleInPackageChannelStub(arg1, arg2, arg3)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.getBundleInPackageChannelReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeInterface) GetBundleInPackageChannelCallCount() int {
-	fake.getBundleInPackageChannelMutex.RLock()
-	defer fake.getBundleInPackageChannelMutex.RUnlock()
-	return len(fake.getBundleInPackageChannelArgsForCall)
-}
-
-func (fake *FakeInterface) GetBundleInPackageChannelCalls(stub func(context.Context, string, string) (*api.Bundle, error)) {
-	fake.getBundleInPackageChannelMutex.Lock()
-	defer fake.getBundleInPackageChannelMutex.Unlock()
-	fake.GetBundleInPackageChannelStub = stub
-}
-
-func (fake *FakeInterface) GetBundleInPackageChannelArgsForCall(i int) (context.Context, string, string) {
-	fake.getBundleInPackageChannelMutex.RLock()
-	defer fake.getBundleInPackageChannelMutex.RUnlock()
-	argsForCall := fake.getBundleInPackageChannelArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *FakeInterface) GetBundleInPackageChannelReturns(result1 *api.Bundle, result2 error) {
-	fake.getBundleInPackageChannelMutex.Lock()
-	defer fake.getBundleInPackageChannelMutex.Unlock()
-	fake.GetBundleInPackageChannelStub = nil
-	fake.getBundleInPackageChannelReturns = struct {
-		result1 *api.Bundle
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeInterface) GetBundleInPackageChannelReturnsOnCall(i int, result1 *api.Bundle, result2 error) {
-	fake.getBundleInPackageChannelMutex.Lock()
-	defer fake.getBundleInPackageChannelMutex.Unlock()
-	fake.GetBundleInPackageChannelStub = nil
-	if fake.getBundleInPackageChannelReturnsOnCall == nil {
-		fake.getBundleInPackageChannelReturnsOnCall = make(map[int]struct {
-			result1 *api.Bundle
-			result2 error
-		})
-	}
-	fake.getBundleInPackageChannelReturnsOnCall[i] = struct {
-		result1 *api.Bundle
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeInterface) GetBundleThatProvides(arg1 context.Context, arg2 string, arg3 string, arg4 string) (*api.Bundle, error) {
-	fake.getBundleThatProvidesMutex.Lock()
-	ret, specificReturn := fake.getBundleThatProvidesReturnsOnCall[len(fake.getBundleThatProvidesArgsForCall)]
-	fake.getBundleThatProvidesArgsForCall = append(fake.getBundleThatProvidesArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 string
-	}{arg1, arg2, arg3, arg4})
-	fake.recordInvocation("GetBundleThatProvides", []interface{}{arg1, arg2, arg3, arg4})
-	fake.getBundleThatProvidesMutex.Unlock()
-	if fake.GetBundleThatProvidesStub != nil {
-		return fake.GetBundleThatProvidesStub(arg1, arg2, arg3, arg4)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.getBundleThatProvidesReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeInterface) GetBundleThatProvidesCallCount() int {
-	fake.getBundleThatProvidesMutex.RLock()
-	defer fake.getBundleThatProvidesMutex.RUnlock()
-	return len(fake.getBundleThatProvidesArgsForCall)
-}
-
-func (fake *FakeInterface) GetBundleThatProvidesCalls(stub func(context.Context, string, string, string) (*api.Bundle, error)) {
-	fake.getBundleThatProvidesMutex.Lock()
-	defer fake.getBundleThatProvidesMutex.Unlock()
-	fake.GetBundleThatProvidesStub = stub
-}
-
-func (fake *FakeInterface) GetBundleThatProvidesArgsForCall(i int) (context.Context, string, string, string) {
-	fake.getBundleThatProvidesMutex.RLock()
-	defer fake.getBundleThatProvidesMutex.RUnlock()
-	argsForCall := fake.getBundleThatProvidesArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
-}
-
-func (fake *FakeInterface) GetBundleThatProvidesReturns(result1 *api.Bundle, result2 error) {
-	fake.getBundleThatProvidesMutex.Lock()
-	defer fake.getBundleThatProvidesMutex.Unlock()
-	fake.GetBundleThatProvidesStub = nil
-	fake.getBundleThatProvidesReturns = struct {
-		result1 *api.Bundle
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeInterface) GetBundleThatProvidesReturnsOnCall(i int, result1 *api.Bundle, result2 error) {
-	fake.getBundleThatProvidesMutex.Lock()
-	defer fake.getBundleThatProvidesMutex.Unlock()
-	fake.GetBundleThatProvidesStub = nil
-	if fake.getBundleThatProvidesReturnsOnCall == nil {
-		fake.getBundleThatProvidesReturnsOnCall = make(map[int]struct {
-			result1 *api.Bundle
-			result2 error
-		})
-	}
-	fake.getBundleThatProvidesReturnsOnCall[i] = struct {
-		result1 *api.Bundle
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeInterface) GetPackage(arg1 context.Context, arg2 string) (*api.Package, error) {
-	fake.getPackageMutex.Lock()
-	ret, specificReturn := fake.getPackageReturnsOnCall[len(fake.getPackageArgsForCall)]
-	fake.getPackageArgsForCall = append(fake.getPackageArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-	}{arg1, arg2})
-	fake.recordInvocation("GetPackage", []interface{}{arg1, arg2})
-	fake.getPackageMutex.Unlock()
-	if fake.GetPackageStub != nil {
-		return fake.GetPackageStub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.getPackageReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeInterface) GetPackageCallCount() int {
-	fake.getPackageMutex.RLock()
-	defer fake.getPackageMutex.RUnlock()
-	return len(fake.getPackageArgsForCall)
-}
-
-func (fake *FakeInterface) GetPackageCalls(stub func(context.Context, string) (*api.Package, error)) {
-	fake.getPackageMutex.Lock()
-	defer fake.getPackageMutex.Unlock()
-	fake.GetPackageStub = stub
-}
-
-func (fake *FakeInterface) GetPackageArgsForCall(i int) (context.Context, string) {
-	fake.getPackageMutex.RLock()
-	defer fake.getPackageMutex.RUnlock()
-	argsForCall := fake.getPackageArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeInterface) GetPackageReturns(result1 *api.Package, result2 error) {
-	fake.getPackageMutex.Lock()
-	defer fake.getPackageMutex.Unlock()
-	fake.GetPackageStub = nil
-	fake.getPackageReturns = struct {
-		result1 *api.Package
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeInterface) GetPackageReturnsOnCall(i int, result1 *api.Package, result2 error) {
-	fake.getPackageMutex.Lock()
-	defer fake.getPackageMutex.Unlock()
-	fake.GetPackageStub = nil
-	if fake.getPackageReturnsOnCall == nil {
-		fake.getPackageReturnsOnCall = make(map[int]struct {
-			result1 *api.Package
-			result2 error
-		})
-	}
-	fake.getPackageReturnsOnCall[i] = struct {
-		result1 *api.Package
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeInterface) GetReplacementBundleInPackageChannel(arg1 context.Context, arg2 string, arg3 string, arg4 string) (*api.Bundle, error) {
-	fake.getReplacementBundleInPackageChannelMutex.Lock()
-	ret, specificReturn := fake.getReplacementBundleInPackageChannelReturnsOnCall[len(fake.getReplacementBundleInPackageChannelArgsForCall)]
-	fake.getReplacementBundleInPackageChannelArgsForCall = append(fake.getReplacementBundleInPackageChannelArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 string
-	}{arg1, arg2, arg3, arg4})
-	fake.recordInvocation("GetReplacementBundleInPackageChannel", []interface{}{arg1, arg2, arg3, arg4})
-	fake.getReplacementBundleInPackageChannelMutex.Unlock()
-	if fake.GetReplacementBundleInPackageChannelStub != nil {
-		return fake.GetReplacementBundleInPackageChannelStub(arg1, arg2, arg3, arg4)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.getReplacementBundleInPackageChannelReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeInterface) GetReplacementBundleInPackageChannelCallCount() int {
-	fake.getReplacementBundleInPackageChannelMutex.RLock()
-	defer fake.getReplacementBundleInPackageChannelMutex.RUnlock()
-	return len(fake.getReplacementBundleInPackageChannelArgsForCall)
-}
-
-func (fake *FakeInterface) GetReplacementBundleInPackageChannelCalls(stub func(context.Context, string, string, string) (*api.Bundle, error)) {
-	fake.getReplacementBundleInPackageChannelMutex.Lock()
-	defer fake.getReplacementBundleInPackageChannelMutex.Unlock()
-	fake.GetReplacementBundleInPackageChannelStub = stub
-}
-
-func (fake *FakeInterface) GetReplacementBundleInPackageChannelArgsForCall(i int) (context.Context, string, string, string) {
-	fake.getReplacementBundleInPackageChannelMutex.RLock()
-	defer fake.getReplacementBundleInPackageChannelMutex.RUnlock()
-	argsForCall := fake.getReplacementBundleInPackageChannelArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
-}
-
-func (fake *FakeInterface) GetReplacementBundleInPackageChannelReturns(result1 *api.Bundle, result2 error) {
-	fake.getReplacementBundleInPackageChannelMutex.Lock()
-	defer fake.getReplacementBundleInPackageChannelMutex.Unlock()
-	fake.GetReplacementBundleInPackageChannelStub = nil
-	fake.getReplacementBundleInPackageChannelReturns = struct {
-		result1 *api.Bundle
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeInterface) GetReplacementBundleInPackageChannelReturnsOnCall(i int, result1 *api.Bundle, result2 error) {
-	fake.getReplacementBundleInPackageChannelMutex.Lock()
-	defer fake.getReplacementBundleInPackageChannelMutex.Unlock()
-	fake.GetReplacementBundleInPackageChannelStub = nil
-	if fake.getReplacementBundleInPackageChannelReturnsOnCall == nil {
-		fake.getReplacementBundleInPackageChannelReturnsOnCall = make(map[int]struct {
-			result1 *api.Bundle
-			result2 error
-		})
-	}
-	fake.getReplacementBundleInPackageChannelReturnsOnCall[i] = struct {
-		result1 *api.Bundle
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeInterface) HealthCheck(arg1 context.Context, arg2 time.Duration) (bool, error) {
-	fake.healthCheckMutex.Lock()
-	ret, specificReturn := fake.healthCheckReturnsOnCall[len(fake.healthCheckArgsForCall)]
-	fake.healthCheckArgsForCall = append(fake.healthCheckArgsForCall, struct {
-		arg1 context.Context
-		arg2 time.Duration
-	}{arg1, arg2})
-	fake.recordInvocation("HealthCheck", []interface{}{arg1, arg2})
-	fake.healthCheckMutex.Unlock()
-	if fake.HealthCheckStub != nil {
-		return fake.HealthCheckStub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.healthCheckReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeInterface) HealthCheckCallCount() int {
-	fake.healthCheckMutex.RLock()
-	defer fake.healthCheckMutex.RUnlock()
-	return len(fake.healthCheckArgsForCall)
-}
-
-func (fake *FakeInterface) HealthCheckCalls(stub func(context.Context, time.Duration) (bool, error)) {
-	fake.healthCheckMutex.Lock()
-	defer fake.healthCheckMutex.Unlock()
-	fake.HealthCheckStub = stub
-}
-
-func (fake *FakeInterface) HealthCheckArgsForCall(i int) (context.Context, time.Duration) {
-	fake.healthCheckMutex.RLock()
-	defer fake.healthCheckMutex.RUnlock()
-	argsForCall := fake.healthCheckArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeInterface) HealthCheckReturns(result1 bool, result2 error) {
-	fake.healthCheckMutex.Lock()
-	defer fake.healthCheckMutex.Unlock()
-	fake.HealthCheckStub = nil
-	fake.healthCheckReturns = struct {
-		result1 bool
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeInterface) HealthCheckReturnsOnCall(i int, result1 bool, result2 error) {
-	fake.healthCheckMutex.Lock()
-	defer fake.healthCheckMutex.Unlock()
-	fake.HealthCheckStub = nil
-	if fake.healthCheckReturnsOnCall == nil {
-		fake.healthCheckReturnsOnCall = make(map[int]struct {
-			result1 bool
-			result2 error
-		})
-	}
-	fake.healthCheckReturnsOnCall[i] = struct {
-		result1 bool
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeInterface) ListBundles(arg1 context.Context) (*client.BundleIterator, error) {
-	fake.listBundlesMutex.Lock()
-	ret, specificReturn := fake.listBundlesReturnsOnCall[len(fake.listBundlesArgsForCall)]
-	fake.listBundlesArgsForCall = append(fake.listBundlesArgsForCall, struct {
-		arg1 context.Context
-	}{arg1})
-	fake.recordInvocation("ListBundles", []interface{}{arg1})
-	fake.listBundlesMutex.Unlock()
-	if fake.ListBundlesStub != nil {
-		return fake.ListBundlesStub(arg1)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.listBundlesReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeInterface) ListBundlesCallCount() int {
-	fake.listBundlesMutex.RLock()
-	defer fake.listBundlesMutex.RUnlock()
-	return len(fake.listBundlesArgsForCall)
-}
-
-func (fake *FakeInterface) ListBundlesCalls(stub func(context.Context) (*client.BundleIterator, error)) {
-	fake.listBundlesMutex.Lock()
-	defer fake.listBundlesMutex.Unlock()
-	fake.ListBundlesStub = stub
-}
-
-func (fake *FakeInterface) ListBundlesArgsForCall(i int) context.Context {
-	fake.listBundlesMutex.RLock()
-	defer fake.listBundlesMutex.RUnlock()
-	argsForCall := fake.listBundlesArgsForCall[i]
-	return argsForCall.arg1
-}
-
-func (fake *FakeInterface) ListBundlesReturns(result1 *client.BundleIterator, result2 error) {
-	fake.listBundlesMutex.Lock()
-	defer fake.listBundlesMutex.Unlock()
-	fake.ListBundlesStub = nil
-	fake.listBundlesReturns = struct {
-		result1 *client.BundleIterator
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeInterface) ListBundlesReturnsOnCall(i int, result1 *client.BundleIterator, result2 error) {
-	fake.listBundlesMutex.Lock()
-	defer fake.listBundlesMutex.Unlock()
-	fake.ListBundlesStub = nil
-	if fake.listBundlesReturnsOnCall == nil {
-		fake.listBundlesReturnsOnCall = make(map[int]struct {
-			result1 *client.BundleIterator
-			result2 error
-		})
-	}
-	fake.listBundlesReturnsOnCall[i] = struct {
-		result1 *client.BundleIterator
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeInterface) Invocations() map[string][][]interface{} {
-	fake.invocationsMutex.RLock()
-	defer fake.invocationsMutex.RUnlock()
-	fake.closeMutex.RLock()
-	defer fake.closeMutex.RUnlock()
-	fake.getBundleMutex.RLock()
-	defer fake.getBundleMutex.RUnlock()
-	fake.getBundleInPackageChannelMutex.RLock()
-	defer fake.getBundleInPackageChannelMutex.RUnlock()
-	fake.getBundleThatProvidesMutex.RLock()
-	defer fake.getBundleThatProvidesMutex.RUnlock()
-	fake.getPackageMutex.RLock()
-	defer fake.getPackageMutex.RUnlock()
-	fake.getReplacementBundleInPackageChannelMutex.RLock()
-	defer fake.getReplacementBundleInPackageChannelMutex.RUnlock()
-	fake.healthCheckMutex.RLock()
-	defer fake.healthCheckMutex.RUnlock()
-	fake.listBundlesMutex.RLock()
-	defer fake.listBundlesMutex.RUnlock()
-	copiedInvocations := map[string][][]interface{}{}
-	for key, value := range fake.invocations {
-		copiedInvocations[key] = value
-	}
-	return copiedInvocations
-}
-
-func (fake *FakeInterface) recordInvocation(key string, args []interface{}) {
-	fake.invocationsMutex.Lock()
-	defer fake.invocationsMutex.Unlock()
-	if fake.invocations == nil {
-		fake.invocations = map[string][][]interface{}{}
-	}
-	if fake.invocations[key] == nil {
-		fake.invocations[key] = [][]interface{}{}
-	}
-	fake.invocations[key] = append(fake.invocations[key], args)
-}
-
-var _ client.Interface = new(FakeInterface)
diff --git a/pkg/controller/registry/resolver/installabletypes.go b/pkg/controller/registry/resolver/installabletypes.go
index 94302d53e..ba9cd602b 100644
--- a/pkg/controller/registry/resolver/installabletypes.go
+++ b/pkg/controller/registry/resolver/installabletypes.go
@@ -60,7 +60,7 @@ func NewBundleInstallableFromOperator(o *cache.Operator) (BundleInstallable, err
 	if o.SourceInfo == nil {
 		return BundleInstallable{}, fmt.Errorf("unable to resolve the source of bundle %s", o.Name)
 	}
-	id := bundleId(o.Identifier(), o.Channel(), o.SourceInfo.Catalog)
+	id := bundleId(o.Name, o.Channel(), o.SourceInfo.Catalog)
 	var constraints []solver.Constraint
 	if o.SourceInfo.Catalog.Virtual() && o.SourceInfo.Subscription == nil {
 		// CSVs already associated with a Subscription
@@ -68,7 +68,7 @@ func NewBundleInstallableFromOperator(o *cache.Operator) (BundleInstallable, err
 		// appear in any solution.
 		constraints = append(constraints, PrettyConstraint(
 			solver.Mandatory(),
-			fmt.Sprintf("clusterserviceversion %s exists and is not referenced by a subscription", o.Identifier()),
+			fmt.Sprintf("clusterserviceversion %s exists and is not referenced by a subscription", o.Name),
 		))
 	}
 	for _, p := range o.Properties {
diff --git a/pkg/controller/registry/resolver/instrumented_resolver.go b/pkg/controller/registry/resolver/instrumented_resolver.go
index 823ceb397..d8af9350c 100644
--- a/pkg/controller/registry/resolver/instrumented_resolver.go
+++ b/pkg/controller/registry/resolver/instrumented_resolver.go
@@ -24,9 +24,9 @@ func NewInstrumentedResolver(resolver StepResolver, successMetricsEmitter, failu
 	}
 }
 
-func (ir *InstrumentedResolver) ResolveSteps(namespace string, sourceQuerier SourceQuerier) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) {
+func (ir *InstrumentedResolver) ResolveSteps(namespace string) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) {
 	start := time.Now()
-	steps, lookups, subs, err := ir.resolver.ResolveSteps(namespace, sourceQuerier)
+	steps, lookups, subs, err := ir.resolver.ResolveSteps(namespace)
 	if err != nil {
 		ir.failureMetricsEmitter(time.Now().Sub(start))
 	} else {
diff --git a/pkg/controller/registry/resolver/querier.go b/pkg/controller/registry/resolver/querier.go
deleted file mode 100644
index 7acbc8a8a..000000000
--- a/pkg/controller/registry/resolver/querier.go
+++ /dev/null
@@ -1,197 +0,0 @@
-//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -o fakes/fake_registry_client.go ../../../../vendor/github.com/operator-framework/operator-registry/pkg/api.RegistryClient
-//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -o fakes/fake_registry_interface.go ../../../../vendor/github.com/operator-framework/operator-registry/pkg/client/client.go Interface
-package resolver
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/blang/semver/v4"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/util/errors"
-
-	"github.com/operator-framework/operator-registry/pkg/api"
-	registryapi "github.com/operator-framework/operator-registry/pkg/api"
-	"github.com/operator-framework/operator-registry/pkg/client"
-	opregistry "github.com/operator-framework/operator-registry/pkg/registry"
-
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry"
-)
-
-const SkipPackageAnnotationKey = "olm.skipRange"
-
-type SourceRef struct {
-	Address     string
-	Client      client.Interface
-	LastConnect metav1.Time
-	LastHealthy metav1.Time
-}
-
-type SourceQuerier interface {
-	FindProvider(api opregistry.APIKey, initialSource registry.CatalogKey, excludedPackages map[string]struct{}) (*api.Bundle, *registry.CatalogKey, error)
-	FindBundle(pkgName, channelName, bundleName string, initialSource registry.CatalogKey) (*api.Bundle, *registry.CatalogKey, error)
-	FindLatestBundle(pkgName, channelName string, initialSource registry.CatalogKey) (*api.Bundle, *registry.CatalogKey, error)
-	FindReplacement(currentVersion *semver.Version, bundleName, pkgName, channelName string, initialSource registry.CatalogKey) (*api.Bundle, *registry.CatalogKey, error)
-	Queryable() error
-}
-
-type NamespaceSourceQuerier struct {
-	sources map[registry.CatalogKey]registry.ClientInterface
-}
-
-var _ SourceQuerier = &NamespaceSourceQuerier{}
-
-func NewNamespaceSourceQuerier(sources map[registry.CatalogKey]registry.ClientInterface) *NamespaceSourceQuerier {
-	return &NamespaceSourceQuerier{
-		sources: sources,
-	}
-}
-
-func (q *NamespaceSourceQuerier) Queryable() error {
-	if len(q.sources) == 0 {
-		return fmt.Errorf("no catalog sources available")
-	}
-	return nil
-}
-
-func (q *NamespaceSourceQuerier) FindProvider(api opregistry.APIKey, initialSource registry.CatalogKey, excludedPackages map[string]struct{}) (*registryapi.Bundle, *registry.CatalogKey, error) {
-	if initialSource.Name != "" && initialSource.Namespace != "" {
-		source, ok := q.sources[initialSource]
-		if ok {
-			if bundle, err := source.FindBundleThatProvides(context.TODO(), api.Group, api.Version, api.Kind, excludedPackages); err == nil {
-				return bundle, &initialSource, nil
-			}
-			if bundle, err := source.FindBundleThatProvides(context.TODO(), api.Plural+"."+api.Group, api.Version, api.Kind, excludedPackages); err == nil {
-				return bundle, &initialSource, nil
-			}
-		}
-	}
-	for key, source := range q.sources {
-		if bundle, err := source.FindBundleThatProvides(context.TODO(), api.Group, api.Version, api.Kind, excludedPackages); err == nil {
-			return bundle, &key, nil
-		}
-		if bundle, err := source.FindBundleThatProvides(context.TODO(), api.Plural+"."+api.Group, api.Version, api.Kind, excludedPackages); err == nil {
-			return bundle, &key, nil
-		}
-	}
-	return nil, nil, fmt.Errorf("%s not provided by a package in any CatalogSource", api)
-}
-
-func (q *NamespaceSourceQuerier) FindBundle(pkgName, channelName, bundleName string, initialSource registry.CatalogKey) (*api.Bundle, *registry.CatalogKey, error) {
-	if initialSource.Name != "" && initialSource.Namespace != "" {
-		source, ok := q.sources[initialSource]
-		if !ok {
-			return nil, nil, fmt.Errorf("CatalogSource %s not found", initialSource)
-		}
-
-		bundle, err := source.GetBundle(context.TODO(), pkgName, channelName, bundleName)
-		if err != nil {
-			return nil, nil, err
-		}
-		return bundle, &initialSource, nil
-	}
-
-	for key, source := range q.sources {
-		bundle, err := source.GetBundle(context.TODO(), pkgName, channelName, bundleName)
-		if err == nil {
-			return bundle, &key, nil
-		}
-	}
-	return nil, nil, fmt.Errorf("%s/%s/%s not found in any available CatalogSource", pkgName, channelName, bundleName)
-}
-
-func (q *NamespaceSourceQuerier) FindLatestBundle(pkgName, channelName string, initialSource registry.CatalogKey) (*api.Bundle, *registry.CatalogKey, error) {
-	if initialSource.Name != "" && initialSource.Namespace != "" {
-		source, ok := q.sources[initialSource]
-		if !ok {
-			return nil, nil, fmt.Errorf("CatalogSource %s not found", initialSource)
-		}
-
-		bundle, err := source.GetBundleInPackageChannel(context.TODO(), pkgName, channelName)
-		if err != nil {
-			return nil, nil, err
-		}
-		return bundle, &initialSource, nil
-	}
-
-	for key, source := range q.sources {
-		bundle, err := source.GetBundleInPackageChannel(context.TODO(), pkgName, channelName)
-		if err == nil {
-			return bundle, &key, nil
-		}
-	}
-	return nil, nil, fmt.Errorf("%s/%s not found in any available CatalogSource", pkgName, channelName)
-}
-
-func (q *NamespaceSourceQuerier) FindReplacement(currentVersion *semver.Version, bundleName, pkgName, channelName string, initialSource registry.CatalogKey) (*api.Bundle, *registry.CatalogKey, error) {
-	errs := []error{}
-
-	if initialSource.Name != "" && initialSource.Namespace != "" {
-		source, ok := q.sources[initialSource]
-		if !ok {
-			return nil, nil, fmt.Errorf("CatalogSource %s not found", initialSource.Name)
-		}
-
-		bundle, err := q.findChannelHead(currentVersion, pkgName, channelName, source)
-		if bundle != nil {
-			return bundle, &initialSource, nil
-		}
-		if err != nil {
-			errs = append(errs, err)
-		}
-
-		bundle, err = source.GetReplacementBundleInPackageChannel(context.TODO(), bundleName, pkgName, channelName)
-		if bundle != nil {
-			return bundle, &initialSource, nil
-		}
-		if err != nil {
-			errs = append(errs, err)
-		}
-
-		return nil, nil, errors.NewAggregate(errs)
-	}
-
-	for key, source := range q.sources {
-		bundle, err := q.findChannelHead(currentVersion, pkgName, channelName, source)
-		if bundle != nil {
-			return bundle, &initialSource, nil
-		}
-		if err != nil {
-			errs = append(errs, err)
-		}
-
-		bundle, err = source.GetReplacementBundleInPackageChannel(context.TODO(), bundleName, pkgName, channelName)
-		if bundle != nil {
-			return bundle, &key, nil
-		}
-		if err != nil {
-			errs = append(errs, err)
-		}
-	}
-	return nil, nil, errors.NewAggregate(errs)
-}
-
-func (q *NamespaceSourceQuerier) findChannelHead(currentVersion *semver.Version, pkgName, channelName string, source client.Interface) (*api.Bundle, error) {
-	if currentVersion == nil {
-		return nil, nil
-	}
-
-	latest, err := source.GetBundleInPackageChannel(context.TODO(), pkgName, channelName)
-	if err != nil {
-		return nil, err
-	}
-
-	if latest.SkipRange == "" {
-		return nil, nil
-	}
-
-	r, err := semver.ParseRange(latest.SkipRange)
-	if err != nil {
-		return nil, err
-	}
-
-	if r(*currentVersion) {
-		return latest, nil
-	}
-	return nil, nil
-}
diff --git a/pkg/controller/registry/resolver/resolver.go b/pkg/controller/registry/resolver/resolver.go
index a8eeaf51b..06d9c10c7 100644
--- a/pkg/controller/registry/resolver/resolver.go
+++ b/pkg/controller/registry/resolver/resolver.go
@@ -51,7 +51,7 @@ func (r *SatResolver) SolveOperators(namespaces []string, csvs []*v1alpha1.Clust
 	var errs []error
 
 	installables := make(map[solver.Identifier]solver.Installable, 0)
-	visited := make(map[cache.OperatorSurface]*BundleInstallable, 0)
+	visited := make(map[*cache.Operator]*BundleInstallable, 0)
 
 	// TODO: better abstraction
 	startingCSVs := make(map[string]struct{})
@@ -141,7 +141,7 @@ func (r *SatResolver) SolveOperators(namespaces []string, csvs []*v1alpha1.Clust
 		}
 	}
 
-	operators := make(map[string]cache.OperatorSurface, 0)
+	operators := make(map[string]*cache.Operator, 0)
 	for _, installableOperator := range operatorInstallables {
 		csvName, channel, catalog, err := installableOperator.BundleSourceInfo()
 		if err != nil {
@@ -173,7 +173,7 @@ func (r *SatResolver) SolveOperators(namespaces []string, csvs []*v1alpha1.Clust
 	return operators, nil
 }
 
-func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, current *cache.Operator, namespacedCache cache.MultiCatalogOperatorFinder, visited map[cache.OperatorSurface]*BundleInstallable) (map[solver.Identifier]solver.Installable, error) {
+func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, current *cache.Operator, namespacedCache cache.MultiCatalogOperatorFinder, visited map[*cache.Operator]*BundleInstallable) (map[solver.Identifier]solver.Installable, error) {
 	var cachePredicates, channelPredicates []cache.OperatorPredicate
 	installables := make(map[solver.Identifier]solver.Installable, 0)
 
@@ -189,7 +189,7 @@ func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, cu
 		csvPredicate := cache.True()
 		if current != nil {
 			// if we found an existing installed operator, we should filter the channel by operators that can replace it
-			channelPredicates = append(channelPredicates, cache.Or(cache.SkipRangeIncludesPredicate(*current.Version), cache.ReplacesPredicate(current.Identifier())))
+			channelPredicates = append(channelPredicates, cache.Or(cache.SkipRangeIncludesPredicate(*current.Version), cache.ReplacesPredicate(current.Name)))
 		} else if sub.Spec.StartingCSV != "" {
 			// if no operator is installed and we have a startingCSV, filter for it
 			csvPredicate = cache.CSVNamePredicate(sub.Spec.StartingCSV)
@@ -257,7 +257,7 @@ func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, cu
 
 	candidates := make([]*BundleInstallable, 0)
 	for _, o := range cache.Filter(sortedBundles, channelPredicates...) {
-		predicates := append(cachePredicates, cache.CSVNamePredicate(o.Identifier()))
+		predicates := append(cachePredicates, cache.CSVNamePredicate(o.Name))
 		stack := namespacedCache.Catalog(catalog).Find(predicates...)
 		id, installable, err := r.getBundleInstallables(catalog, stack, namespacedCache, visited)
 		if err != nil {
@@ -279,7 +279,7 @@ func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, cu
 	for _, c := range candidates {
 		// track which operator this is replacing, so that it can be realized when creating the resources on cluster
 		if current != nil {
-			c.Replaces = current.Identifier()
+			c.Replaces = current.Name
 			// Package name can't be reliably inferred
 			// from a CSV without a projected package
 			// property, so for the replacement case, a
@@ -288,12 +288,12 @@ func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, cu
 			// safe to remove this conflict if properties
 			// annotations are made mandatory for
 			// resolution.
-			c.AddConflict(bundleId(current.Identifier(), current.Channel(), registry.NewVirtualCatalogKey(sub.GetNamespace())))
+			c.AddConflict(bundleId(current.Name, current.Channel(), registry.NewVirtualCatalogKey(sub.GetNamespace())))
 		}
 		depIds = append(depIds, c.Identifier())
 	}
 	if current != nil {
-		depIds = append(depIds, bundleId(current.Identifier(), current.Channel(), registry.NewVirtualCatalogKey(sub.GetNamespace())))
+		depIds = append(depIds, bundleId(current.Name, current.Channel(), registry.NewVirtualCatalogKey(sub.GetNamespace())))
 	}
 
 	// all candidates added as options for this constraint
@@ -303,7 +303,7 @@ func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, cu
 	return installables, nil
 }
 
-func (r *SatResolver) getBundleInstallables(catalog registry.CatalogKey, bundleStack []*cache.Operator, namespacedCache cache.MultiCatalogOperatorFinder, visited map[cache.OperatorSurface]*BundleInstallable) (map[solver.Identifier]struct{}, map[solver.Identifier]*BundleInstallable, error) {
+func (r *SatResolver) getBundleInstallables(catalog registry.CatalogKey, bundleStack []*cache.Operator, namespacedCache cache.MultiCatalogOperatorFinder, visited map[*cache.Operator]*BundleInstallable) (map[solver.Identifier]struct{}, map[solver.Identifier]*BundleInstallable, error) {
 	errs := make([]error, 0)
 	installables := make(map[solver.Identifier]*BundleInstallable, 0) // all installables, including dependencies
 
@@ -359,7 +359,7 @@ func (r *SatResolver) getBundleInstallables(catalog registry.CatalogKey, bundleS
 
 				if si.Catalog.Virtual() {
 					sourcePredicate = cache.Or(sourcePredicate, cache.And(
-						cache.CSVNamePredicate(b.Identifier()),
+						cache.CSVNamePredicate(b.Name),
 						cache.CatalogPredicate(si.Catalog),
 					))
 				} else {
@@ -653,7 +653,7 @@ func sortChannel(bundles []*cache.Operator) ([]*cache.Operator, error) {
 	skipped := map[string]*cache.Operator{}
 
 	for _, b := range bundles {
-		bundleLookup[b.Identifier()] = b
+		bundleLookup[b.Name] = b
 	}
 
 	for _, b := range bundles {
@@ -690,7 +690,7 @@ func sortChannel(bundles []*cache.Operator) ([]*cache.Operator, error) {
 		current := head
 		for {
 			visited[current] = struct{}{}
-			if _, ok := skipped[current.Identifier()]; !ok {
+			if _, ok := skipped[current.Name]; !ok {
 				chain = append(chain, current)
 			}
 			next, ok := replaces[current]
@@ -698,7 +698,7 @@ func sortChannel(bundles []*cache.Operator) ([]*cache.Operator, error) {
 				break
 			}
 			if _, ok := visited[next]; ok {
-				return nil, fmt.Errorf("a cycle exists in the chain of replacement beginning with %q in channel %q of package %q", head.Identifier(), channelName, packageName)
+				return nil, fmt.Errorf("a cycle exists in the chain of replacement beginning with %q in channel %q of package %q", head.Name, channelName, packageName)
 			}
 			current = next
 		}
@@ -712,9 +712,9 @@ func sortChannel(bundles []*cache.Operator) ([]*cache.Operator, error) {
 			case 0:
 				schains[i] = "[]" // Bug?
 			case 1:
-				schains[i] = chain[0].Identifier()
+				schains[i] = chain[0].Name
 			default:
-				schains[i] = fmt.Sprintf("%s...%s", chain[0].Identifier(), chain[len(chain)-1].Identifier())
+				schains[i] = fmt.Sprintf("%s...%s", chain[0].Name, chain[len(chain)-1].Name)
 			}
 		}
 		return nil, fmt.Errorf("a unique replacement chain within a channel is required to determine the relative order between channel entries, but %d replacement chains were found in channel %q of package %q: %s", len(schains), channelName, packageName, strings.Join(schains, ", "))
diff --git a/pkg/controller/registry/resolver/step_resolver.go b/pkg/controller/registry/resolver/step_resolver.go
index 9fb369ca3..a696dfd65 100644
--- a/pkg/controller/registry/resolver/step_resolver.go
+++ b/pkg/controller/registry/resolver/step_resolver.go
@@ -1,4 +1,3 @@
-//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -o fakes/fake_registry_interface.go ../../../../vendor/github.com/operator-framework/operator-registry/pkg/client/client.go Interface
 //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -o ../../../fakes/fake_resolver.go . StepResolver
 package resolver
 
@@ -31,7 +30,7 @@ const (
 var timeNow = func() metav1.Time { return metav1.NewTime(time.Now().UTC()) }
 
 type StepResolver interface {
-	ResolveSteps(namespace string, sourceQuerier SourceQuerier) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error)
+	ResolveSteps(namespace string) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error)
 	Expire(key registry.CatalogKey)
 }
 
@@ -66,7 +65,7 @@ func (r *OperatorStepResolver) Expire(key registry.CatalogKey) {
 	r.satResolver.cache.Expire(key)
 }
 
-func (r *OperatorStepResolver) ResolveSteps(namespace string, _ SourceQuerier) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) {
+func (r *OperatorStepResolver) ResolveSteps(namespace string) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) {
 	// create a generation - a representation of the current set of installed operators and their provided/required apis
 	allCSVs, err := r.csvLister.ClusterServiceVersions(namespace).List(labels.Everything())
 	if err != nil {
@@ -102,7 +101,7 @@ func (r *OperatorStepResolver) ResolveSteps(namespace string, _ SourceQuerier) (
 	for name, op := range operators {
 		// Find any existing subscriptions that resolve to this operator.
 		existingSubscriptions := make(map[*v1alpha1.Subscription]bool)
-		sourceInfo := *op.GetSourceInfo()
+		sourceInfo := *op.SourceInfo
 		for _, sub := range subs {
 			if sub.Spec.Package != sourceInfo.Package {
 				continue
@@ -127,7 +126,7 @@ func (r *OperatorStepResolver) ResolveSteps(namespace string, _ SourceQuerier) (
 		if len(existingSubscriptions) > 0 {
 			upToDate := true
 			for sub, exists := range existingSubscriptions {
-				if !exists || sub.Status.CurrentCSV != op.Identifier() {
+				if !exists || sub.Status.CurrentCSV != op.Name {
 					upToDate = false
 				}
 			}
@@ -138,21 +137,21 @@ func (r *OperatorStepResolver) ResolveSteps(namespace string, _ SourceQuerier) (
 		}
 
 		// add steps for any new bundle
-		if op.GetBundle() != nil {
+		if op.Bundle != nil {
 			if op.Inline() {
-				bundleSteps, err := NewStepsFromBundle(op.GetBundle(), namespace, op.GetReplaces(), op.GetSourceInfo().Catalog.Name, op.GetSourceInfo().Catalog.Namespace)
+				bundleSteps, err := NewStepsFromBundle(op.Bundle, namespace, op.Replaces, op.SourceInfo.Catalog.Name, op.SourceInfo.Catalog.Namespace)
 				if err != nil {
 					return nil, nil, nil, fmt.Errorf("failed to turn bundle into steps: %s", err.Error())
 				}
 				steps = append(steps, bundleSteps...)
 			} else {
 				lookup := v1alpha1.BundleLookup{
-					Path:       op.GetBundle().GetBundlePath(),
-					Identifier: op.Identifier(),
-					Replaces:   op.GetReplaces(),
+					Path:       op.Bundle.GetBundlePath(),
+					Identifier: op.Name,
+					Replaces:   op.Replaces,
 					CatalogSourceRef: &corev1.ObjectReference{
-						Namespace: op.GetSourceInfo().Catalog.Namespace,
-						Name:      op.GetSourceInfo().Catalog.Name,
+						Namespace: op.SourceInfo.Catalog.Namespace,
+						Name:      op.SourceInfo.Catalog.Name,
 					},
 					Conditions: []v1alpha1.BundleLookupCondition{
 						{
@@ -169,8 +168,8 @@ func (r *OperatorStepResolver) ResolveSteps(namespace string, _ SourceQuerier) (
 						},
 					},
 				}
-				if anno, err := projection.PropertiesAnnotationFromPropertyList(op.GetProperties()); err != nil {
-					return nil, nil, nil, fmt.Errorf("failed to serialize operator properties for %q: %w", op.Identifier(), err)
+				if anno, err := projection.PropertiesAnnotationFromPropertyList(op.Properties); err != nil {
+					return nil, nil, nil, fmt.Errorf("failed to serialize operator properties for %q: %w", op.Name, err)
 				} else {
 					lookup.Properties = anno
 				}
@@ -179,8 +178,8 @@ func (r *OperatorStepResolver) ResolveSteps(namespace string, _ SourceQuerier) (
 
 			if len(existingSubscriptions) == 0 {
 				// explicitly track the resolved CSV as the starting CSV on the resolved subscriptions
-				op.GetSourceInfo().StartingCSV = op.Identifier()
-				subStep, err := NewSubscriptionStepResource(namespace, *op.GetSourceInfo())
+				op.SourceInfo.StartingCSV = op.Name
+				subStep, err := NewSubscriptionStepResource(namespace, *op.SourceInfo)
 				if err != nil {
 					return nil, nil, nil, err
 				}
@@ -194,11 +193,11 @@ func (r *OperatorStepResolver) ResolveSteps(namespace string, _ SourceQuerier) (
 
 		// add steps for subscriptions for bundles that were added through resolution
 		for sub := range existingSubscriptions {
-			if sub.Status.CurrentCSV == op.Identifier() {
+			if sub.Status.CurrentCSV == op.Name {
 				continue
 			}
 			// update existing subscription status
-			sub.Status.CurrentCSV = op.Identifier()
+			sub.Status.CurrentCSV = op.Name
 			updatedSubs = append(updatedSubs, sub)
 		}
 	}
diff --git a/pkg/fakes/fake_api_intersection_reconciler.go b/pkg/fakes/fake_api_intersection_reconciler.go
deleted file mode 100644
index 1cfbf3d13..000000000
--- a/pkg/fakes/fake_api_intersection_reconciler.go
+++ /dev/null
@@ -1,115 +0,0 @@
-// Code generated by counterfeiter. DO NOT EDIT.
-package fakes
-
-import (
-	"sync"
-
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver"
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache"
-)
-
-type FakeAPIIntersectionReconciler struct {
-	ReconcileStub        func(cache.APISet, resolver.OperatorGroupSurface, ...resolver.OperatorGroupSurface) resolver.APIReconciliationResult
-	reconcileMutex       sync.RWMutex
-	reconcileArgsForCall []struct {
-		arg1 cache.APISet
-		arg2 resolver.OperatorGroupSurface
-		arg3 []resolver.OperatorGroupSurface
-	}
-	reconcileReturns struct {
-		result1 resolver.APIReconciliationResult
-	}
-	reconcileReturnsOnCall map[int]struct {
-		result1 resolver.APIReconciliationResult
-	}
-	invocations      map[string][][]interface{}
-	invocationsMutex sync.RWMutex
-}
-
-func (fake *FakeAPIIntersectionReconciler) Reconcile(arg1 cache.APISet, arg2 resolver.OperatorGroupSurface, arg3 ...resolver.OperatorGroupSurface) resolver.APIReconciliationResult {
-	fake.reconcileMutex.Lock()
-	ret, specificReturn := fake.reconcileReturnsOnCall[len(fake.reconcileArgsForCall)]
-	fake.reconcileArgsForCall = append(fake.reconcileArgsForCall, struct {
-		arg1 cache.APISet
-		arg2 resolver.OperatorGroupSurface
-		arg3 []resolver.OperatorGroupSurface
-	}{arg1, arg2, arg3})
-	fake.recordInvocation("Reconcile", []interface{}{arg1, arg2, arg3})
-	fake.reconcileMutex.Unlock()
-	if fake.ReconcileStub != nil {
-		return fake.ReconcileStub(arg1, arg2, arg3...)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	fakeReturns := fake.reconcileReturns
-	return fakeReturns.result1
-}
-
-func (fake *FakeAPIIntersectionReconciler) ReconcileCallCount() int {
-	fake.reconcileMutex.RLock()
-	defer fake.reconcileMutex.RUnlock()
-	return len(fake.reconcileArgsForCall)
-}
-
-func (fake *FakeAPIIntersectionReconciler) ReconcileCalls(stub func(cache.APISet, resolver.OperatorGroupSurface, ...resolver.OperatorGroupSurface) resolver.APIReconciliationResult) {
-	fake.reconcileMutex.Lock()
-	defer fake.reconcileMutex.Unlock()
-	fake.ReconcileStub = stub
-}
-
-func (fake *FakeAPIIntersectionReconciler) ReconcileArgsForCall(i int) (cache.APISet, resolver.OperatorGroupSurface, []resolver.OperatorGroupSurface) {
-	fake.reconcileMutex.RLock()
-	defer fake.reconcileMutex.RUnlock()
-	argsForCall := fake.reconcileArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *FakeAPIIntersectionReconciler) ReconcileReturns(result1 resolver.APIReconciliationResult) {
-	fake.reconcileMutex.Lock()
-	defer fake.reconcileMutex.Unlock()
-	fake.ReconcileStub = nil
-	fake.reconcileReturns = struct {
-		result1 resolver.APIReconciliationResult
-	}{result1}
-}
-
-func (fake *FakeAPIIntersectionReconciler) ReconcileReturnsOnCall(i int, result1 resolver.APIReconciliationResult) {
-	fake.reconcileMutex.Lock()
-	defer fake.reconcileMutex.Unlock()
-	fake.ReconcileStub = nil
-	if fake.reconcileReturnsOnCall == nil {
-		fake.reconcileReturnsOnCall = make(map[int]struct {
-			result1 resolver.APIReconciliationResult
-		})
-	}
-	fake.reconcileReturnsOnCall[i] = struct {
-		result1 resolver.APIReconciliationResult
-	}{result1}
-}
-
-func (fake *FakeAPIIntersectionReconciler) Invocations() map[string][][]interface{} {
-	fake.invocationsMutex.RLock()
-	defer fake.invocationsMutex.RUnlock()
-	fake.reconcileMutex.RLock()
-	defer fake.reconcileMutex.RUnlock()
-	copiedInvocations := map[string][][]interface{}{}
-	for key, value := range fake.invocations {
-		copiedInvocations[key] = value
-	}
-	return copiedInvocations
-}
-
-func (fake *FakeAPIIntersectionReconciler) recordInvocation(key string, args []interface{}) {
-	fake.invocationsMutex.Lock()
-	defer fake.invocationsMutex.Unlock()
-	if fake.invocations == nil {
-		fake.invocations = map[string][][]interface{}{}
-	}
-	if fake.invocations[key] == nil {
-		fake.invocations[key] = [][]interface{}{}
-	}
-	fake.invocations[key] = append(fake.invocations[key], args)
-}
-
-var _ resolver.APIIntersectionReconciler = new(FakeAPIIntersectionReconciler)
diff --git a/pkg/fakes/fake_resolver.go b/pkg/fakes/fake_resolver.go
index b24cdcbc1..07ec94e0f 100644
--- a/pkg/fakes/fake_resolver.go
+++ b/pkg/fakes/fake_resolver.go
@@ -15,11 +15,10 @@ type FakeStepResolver struct {
 	expireArgsForCall []struct {
 		arg1 registry.CatalogKey
 	}
-	ResolveStepsStub        func(string, resolver.SourceQuerier) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error)
+	ResolveStepsStub        func(string) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error)
 	resolveStepsMutex       sync.RWMutex
 	resolveStepsArgsForCall []struct {
 		arg1 string
-		arg2 resolver.SourceQuerier
 	}
 	resolveStepsReturns struct {
 		result1 []*v1alpha1.Step
@@ -68,17 +67,16 @@ func (fake *FakeStepResolver) ExpireArgsForCall(i int) registry.CatalogKey {
 	return argsForCall.arg1
 }
 
-func (fake *FakeStepResolver) ResolveSteps(arg1 string, arg2 resolver.SourceQuerier) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) {
+func (fake *FakeStepResolver) ResolveSteps(arg1 string) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) {
 	fake.resolveStepsMutex.Lock()
 	ret, specificReturn := fake.resolveStepsReturnsOnCall[len(fake.resolveStepsArgsForCall)]
 	fake.resolveStepsArgsForCall = append(fake.resolveStepsArgsForCall, struct {
 		arg1 string
-		arg2 resolver.SourceQuerier
-	}{arg1, arg2})
-	fake.recordInvocation("ResolveSteps", []interface{}{arg1, arg2})
+	}{arg1})
+	fake.recordInvocation("ResolveSteps", []interface{}{arg1})
 	fake.resolveStepsMutex.Unlock()
 	if fake.ResolveStepsStub != nil {
-		return fake.ResolveStepsStub(arg1, arg2)
+		return fake.ResolveStepsStub(arg1)
 	}
 	if specificReturn {
 		return ret.result1, ret.result2, ret.result3, ret.result4
@@ -93,17 +91,17 @@ func (fake *FakeStepResolver) ResolveStepsCallCount() int {
 	return len(fake.resolveStepsArgsForCall)
 }
 
-func (fake *FakeStepResolver) ResolveStepsCalls(stub func(string, resolver.SourceQuerier) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error)) {
+func (fake *FakeStepResolver) ResolveStepsCalls(stub func(string) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error)) {
 	fake.resolveStepsMutex.Lock()
 	defer fake.resolveStepsMutex.Unlock()
 	fake.ResolveStepsStub = stub
 }
 
-func (fake *FakeStepResolver) ResolveStepsArgsForCall(i int) (string, resolver.SourceQuerier) {
+func (fake *FakeStepResolver) ResolveStepsArgsForCall(i int) string {
 	fake.resolveStepsMutex.RLock()
 	defer fake.resolveStepsMutex.RUnlock()
 	argsForCall := fake.resolveStepsArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
+	return argsForCall.arg1
 }
 
 func (fake *FakeStepResolver) ResolveStepsReturns(result1 []*v1alpha1.Step, result2 []v1alpha1.BundleLookup, result3 []*v1alpha1.Subscription, result4 error) {


Test patch:
diff --git a/pkg/controller/operators/catalog/operator_test.go b/pkg/controller/operators/catalog/operator_test.go
index b519af62e..5aa398ab5 100644
--- a/pkg/controller/operators/catalog/operator_test.go
+++ b/pkg/controller/operators/catalog/operator_test.go
@@ -1204,7 +1204,7 @@ func TestSyncResolvingNamespace(t *testing.T) {
 
 			o.sourcesLastUpdate.Set(tt.fields.sourcesLastUpdate.Time)
 			o.resolver = &fakes.FakeStepResolver{
-				ResolveStepsStub: func(string, resolver.SourceQuerier) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) {
+				ResolveStepsStub: func(string) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) {
 					return nil, nil, nil, tt.fields.resolveErr
 				},
 			}
diff --git a/pkg/controller/registry/resolver/querier_test.go b/pkg/controller/operators/catalog/querier_test.go
similarity index 55%
rename from pkg/controller/registry/resolver/querier_test.go
rename to pkg/controller/operators/catalog/querier_test.go
index 20d1c0e70..6a220a854 100644
--- a/pkg/controller/registry/resolver/querier_test.go
+++ b/pkg/controller/operators/catalog/querier_test.go
@@ -1,4 +1,4 @@
-package resolver
+package catalog
 
 import (
 	"context"
@@ -9,14 +9,13 @@ import (
 	"github.com/blang/semver/v4"
 	"github.com/operator-framework/operator-registry/pkg/api"
 	"github.com/operator-framework/operator-registry/pkg/client"
-	opregistry "github.com/operator-framework/operator-registry/pkg/registry"
 	"github.com/stretchr/testify/require"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/operator-framework/api/pkg/lib/version"
 	"github.com/operator-framework/api/pkg/operators/v1alpha1"
+	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/fakes"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry"
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/fakes"
 )
 
 func TestNewNamespaceSourceQuerier(t *testing.T) {
@@ -114,237 +113,6 @@ func TestNamespaceSourceQuerier_Queryable(t *testing.T) {
 	}
 }
 
-func TestNamespaceSourceQuerier_FindProvider(t *testing.T) {
-	fakeSource := fakes.FakeClientInterface{}
-	fakeSource2 := fakes.FakeClientInterface{}
-	sources := map[registry.CatalogKey]registry.ClientInterface{
-		registry.CatalogKey{"test", "ns"}:  &fakeSource,
-		registry.CatalogKey{"test2", "ns"}: &fakeSource2,
-	}
-	excludedPkgs := make(map[string]struct{})
-	bundle := &api.Bundle{CsvName: "test", PackageName: "testPkg", ChannelName: "testChannel"}
-	bundle2 := &api.Bundle{CsvName: "test2", PackageName: "testPkg2", ChannelName: "testChannel2"}
-	fakeSource.GetBundleThatProvidesStub = func(ctx context.Context, group, version, kind string) (*api.Bundle, error) {
-		if group != "group" || version != "version" || kind != "kind" {
-			return nil, fmt.Errorf("Not Found")
-		}
-		return bundle, nil
-	}
-	fakeSource2.GetBundleThatProvidesStub = func(ctx context.Context, group, version, kind string) (*api.Bundle, error) {
-		if group != "group2" || version != "version2" || kind != "kind2" {
-			return nil, fmt.Errorf("Not Found")
-		}
-		return bundle2, nil
-	}
-	fakeSource.FindBundleThatProvidesStub = func(ctx context.Context, group, version, kind string, excludedPkgs map[string]struct{}) (*api.Bundle, error) {
-		if group != "group" || version != "version" || kind != "kind" {
-			return nil, fmt.Errorf("Not Found")
-		}
-		return bundle, nil
-	}
-	fakeSource2.FindBundleThatProvidesStub = func(ctx context.Context, group, version, kind string, excludedPkgs map[string]struct{}) (*api.Bundle, error) {
-		if group != "group2" || version != "version2" || kind != "kind2" {
-			return nil, fmt.Errorf("Not Found")
-		}
-		return bundle2, nil
-	}
-
-	type fields struct {
-		sources map[registry.CatalogKey]registry.ClientInterface
-	}
-	type args struct {
-		api        opregistry.APIKey
-		catalogKey registry.CatalogKey
-	}
-	type out struct {
-		bundle *api.Bundle
-		key    *registry.CatalogKey
-		err    error
-	}
-	tests := []struct {
-		name   string
-		fields fields
-		args   args
-		out    out
-	}{
-		{
-			fields: fields{
-				sources: sources,
-			},
-			args: args{
-				api:        opregistry.APIKey{"group", "version", "kind", "plural"},
-				catalogKey: registry.CatalogKey{},
-			},
-			out: out{
-				bundle: bundle,
-				key:    &registry.CatalogKey{Name: "test", Namespace: "ns"},
-				err:    nil,
-			},
-		},
-		{
-			fields: fields{
-				sources: nil,
-			},
-			args: args{
-				api:        opregistry.APIKey{"group", "version", "kind", "plural"},
-				catalogKey: registry.CatalogKey{},
-			},
-			out: out{
-				bundle: nil,
-				key:    nil,
-				err:    fmt.Errorf("group/version/kind (plural) not provided by a package in any CatalogSource"),
-			},
-		},
-		{
-			fields: fields{
-				sources: sources,
-			},
-			args: args{
-				api:        opregistry.APIKey{"group2", "version2", "kind2", "plural2"},
-				catalogKey: registry.CatalogKey{Name: "test2", Namespace: "ns"},
-			},
-			out: out{
-				bundle: bundle2,
-				key:    &registry.CatalogKey{Name: "test2", Namespace: "ns"},
-				err:    nil,
-			},
-		},
-		{
-			fields: fields{
-				sources: sources,
-			},
-			args: args{
-				api:        opregistry.APIKey{"group2", "version2", "kind2", "plural2"},
-				catalogKey: registry.CatalogKey{Name: "test3", Namespace: "ns"},
-			},
-			out: out{
-				bundle: bundle2,
-				key:    &registry.CatalogKey{Name: "test2", Namespace: "ns"},
-				err:    nil,
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			q := &NamespaceSourceQuerier{
-				sources: tt.fields.sources,
-			}
-			bundle, key, err := q.FindProvider(tt.args.api, tt.args.catalogKey, excludedPkgs)
-			require.Equal(t, tt.out.err, err)
-			require.Equal(t, tt.out.bundle, bundle)
-			require.Equal(t, tt.out.key, key)
-		})
-	}
-}
-
-func TestNamespaceSourceQuerier_FindPackage(t *testing.T) {
-	initialSource := fakes.FakeClientInterface{}
-	otherSource := fakes.FakeClientInterface{}
-	initalBundle := &api.Bundle{CsvName: "test", PackageName: "testPkg", ChannelName: "testChannel"}
-	startingBundle := &api.Bundle{CsvName: "starting-test", PackageName: "testPkg", ChannelName: "testChannel"}
-	otherBundle := &api.Bundle{CsvName: "other", PackageName: "otherPkg", ChannelName: "otherChannel"}
-	initialSource.GetBundleStub = func(ctx context.Context, pkgName, channelName, csvName string) (*api.Bundle, error) {
-		if csvName != startingBundle.CsvName {
-			return nil, fmt.Errorf("not found")
-		}
-		return startingBundle, nil
-	}
-	initialSource.GetBundleInPackageChannelStub = func(ctx context.Context, pkgName, channelName string) (*api.Bundle, error) {
-		if pkgName != initalBundle.CsvName {
-			return nil, fmt.Errorf("not found")
-		}
-		return initalBundle, nil
-	}
-	otherSource.GetBundleInPackageChannelStub = func(ctx context.Context, pkgName, channelName string) (*api.Bundle, error) {
-		if pkgName != otherBundle.CsvName {
-			return nil, fmt.Errorf("not found")
-		}
-		return otherBundle, nil
-	}
-	initialKey := registry.CatalogKey{"initial", "ns"}
-	otherKey := registry.CatalogKey{"other", "other"}
-	sources := map[registry.CatalogKey]registry.ClientInterface{
-		initialKey: &initialSource,
-		otherKey:   &otherSource,
-	}
-
-	type fields struct {
-		sources map[registry.CatalogKey]registry.ClientInterface
-	}
-	type args struct {
-		pkgName       string
-		channelName   string
-		startingCSV   string
-		initialSource registry.CatalogKey
-	}
-	type out struct {
-		bundle *api.Bundle
-		key    *registry.CatalogKey
-		err    error
-	}
-	tests := []struct {
-		name   string
-		fields fields
-		args   args
-		out    out
-	}{
-		{
-			name:   "Initial/Found",
-			fields: fields{sources: sources},
-			args:   args{"test", "testChannel", "", registry.CatalogKey{"initial", "ns"}},
-			out:    out{bundle: initalBundle, key: &initialKey, err: nil},
-		},
-		{
-			name:   "Initial/CatalogNotFound",
-			fields: fields{sources: sources},
-			args:   args{"test", "testChannel", "", registry.CatalogKey{"absent", "found"}},
-			out:    out{bundle: nil, key: nil, err: fmt.Errorf("CatalogSource {absent found} not found")},
-		},
-		{
-			name:   "Initial/StartingCSVFound",
-			fields: fields{sources: sources},
-			args:   args{"test", "testChannel", "starting-test", registry.CatalogKey{"initial", "ns"}},
-			out:    out{bundle: startingBundle, key: &initialKey, err: nil},
-		},
-		{
-			name:   "Initial/StartingCSVNotFound",
-			fields: fields{sources: sources},
-			args:   args{"test", "testChannel", "non-existent", registry.CatalogKey{"initial", "ns"}},
-			out:    out{bundle: nil, key: nil, err: fmt.Errorf("not found")},
-		},
-		{
-			name:   "Other/Found",
-			fields: fields{sources: sources},
-			args:   args{"other", "testChannel", "", registry.CatalogKey{"", ""}},
-			out:    out{bundle: otherBundle, key: &otherKey, err: nil},
-		},
-		{
-			name:   "NotFound",
-			fields: fields{sources: sources},
-			args:   args{"nope", "not", "", registry.CatalogKey{"", ""}},
-			out:    out{bundle: nil, err: fmt.Errorf("nope/not not found in any available CatalogSource")},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			q := &NamespaceSourceQuerier{
-				sources: tt.fields.sources,
-			}
-			var got *api.Bundle
-			var key *registry.CatalogKey
-			var err error
-			if tt.args.startingCSV != "" {
-				got, key, err = q.FindBundle(tt.args.pkgName, tt.args.channelName, tt.args.startingCSV, tt.args.initialSource)
-			} else {
-				got, key, err = q.FindLatestBundle(tt.args.pkgName, tt.args.channelName, tt.args.initialSource)
-			}
-			require.Equal(t, tt.out.err, err)
-			require.Equal(t, tt.out.bundle, got)
-			require.Equal(t, tt.out.key, key)
-		})
-	}
-}
-
 func TestNamespaceSourceQuerier_FindReplacement(t *testing.T) {
 	// TODO: clean up this test setup
 	initialSource := fakes.FakeClientInterface{}
diff --git a/pkg/controller/operators/catalog/subscriptions_test.go b/pkg/controller/operators/catalog/subscriptions_test.go
index 0a663f0a9..15e44269f 100644
--- a/pkg/controller/operators/catalog/subscriptions_test.go
+++ b/pkg/controller/operators/catalog/subscriptions_test.go
@@ -1031,7 +1031,7 @@ func TestSyncSubscriptions(t *testing.T) {
 
 			o.sourcesLastUpdate.Set(tt.fields.sourcesLastUpdate.Time)
 			o.resolver = &fakes.FakeStepResolver{
-				ResolveStepsStub: func(string, resolver.SourceQuerier) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) {
+				ResolveStepsStub: func(string) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) {
 					return tt.fields.resolveSteps, tt.fields.bundleLookups, tt.fields.resolveSubs, tt.fields.resolveErr
 				},
 			}
@@ -1167,7 +1167,7 @@ func BenchmarkSyncResolvingNamespace(b *testing.B) {
 				},
 			},
 			resolver: &fakes.FakeStepResolver{
-				ResolveStepsStub: func(string, resolver.SourceQuerier) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) {
+				ResolveStepsStub: func(string) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) {
 					steps := []*v1alpha1.Step{
 						{
 							Resolving: "csv.v.2",
diff --git a/pkg/controller/registry/resolver/groups_test.go b/pkg/controller/operators/olm/groups_test.go
similarity index 99%
rename from pkg/controller/registry/resolver/groups_test.go
rename to pkg/controller/operators/olm/groups_test.go
index 6b2be428d..9534ab459 100644
--- a/pkg/controller/registry/resolver/groups_test.go
+++ b/pkg/controller/operators/olm/groups_test.go
@@ -1,4 +1,4 @@
-package resolver
+package olm
 
 import (
 	"strings"
diff --git a/pkg/controller/registry/resolver/labeler_test.go b/pkg/controller/operators/olm/labeler_test.go
similarity index 72%
rename from pkg/controller/registry/resolver/labeler_test.go
rename to pkg/controller/operators/olm/labeler_test.go
index caf16f972..ca3722e03 100644
--- a/pkg/controller/registry/resolver/labeler_test.go
+++ b/pkg/controller/operators/olm/labeler_test.go
@@ -1,4 +1,4 @@
-package resolver
+package olm
 
 import (
 	"testing"
@@ -6,6 +6,8 @@ import (
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache"
 	opregistry "github.com/operator-framework/operator-registry/pkg/registry"
 	"github.com/stretchr/testify/require"
+	"k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
 )
 
@@ -27,12 +29,29 @@ func TestLabelSetsFor(t *testing.T) {
 		},
 		{
 			name: "CRD/ProvidedAndRequired",
-			obj: crd(opregistry.APIKey{
-				Group:   "ghouls",
-				Version: "v1alpha1",
-				Kind:    "Ghost",
-				Plural:  "Ghosts",
-			}),
+			obj: &v1beta1.CustomResourceDefinition{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "CustomResourceDefinition",
+					APIVersion: v1beta1.SchemeGroupVersion.String(),
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "Ghosts.ghouls",
+				},
+				Spec: v1beta1.CustomResourceDefinitionSpec{
+					Group: "ghouls",
+					Versions: []v1beta1.CustomResourceDefinitionVersion{
+						{
+							Name:    "v1alpha1",
+							Storage: true,
+							Served:  true,
+						},
+					},
+					Names: v1beta1.CustomResourceDefinitionNames{
+						Kind:   "Ghost",
+						Plural: "Ghosts",
+					},
+				},
+			},
 			expected: []labels.Set{
 				{
 					APILabelKeyPrefix + "6435ab0d7c6bda64": "provided",
diff --git a/pkg/controller/operators/olm/operator_test.go b/pkg/controller/operators/olm/operator_test.go
index f7d9abbde..7a28654ca 100644
--- a/pkg/controller/operators/olm/operator_test.go
+++ b/pkg/controller/operators/olm/operator_test.go
@@ -54,9 +54,7 @@ import (
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/certs"
 	olmerrors "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/errors"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install"
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver"
 	resolvercache "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache"
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/fakes"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/lib/clientfake"
 	csvutility "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/csv"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/lib/labeler"
@@ -200,7 +198,7 @@ func withStrategyResolver(strategyResolver install.StrategyResolverInterface) fa
 	}
 }
 
-func withAPIReconciler(apiReconciler resolver.APIIntersectionReconciler) fakeOperatorOption {
+func withAPIReconciler(apiReconciler APIIntersectionReconciler) fakeOperatorOption {
 	return func(config *fakeOperatorConfig) {
 		if apiReconciler != nil {
 			config.apiReconciler = apiReconciler
@@ -269,8 +267,8 @@ func NewFakeOperator(ctx context.Context, options ...fakeOperatorOption) (*Opera
 			clock:             &utilclock.RealClock{},
 			logger:            logrus.New(),
 			strategyResolver:  &install.StrategyResolver{},
-			apiReconciler:     resolver.APIIntersectionReconcileFunc(resolver.ReconcileAPIIntersection),
-			apiLabeler:        labeler.Func(resolver.LabelSetsFor),
+			apiReconciler:     APIIntersectionReconcileFunc(ReconcileAPIIntersection),
+			apiLabeler:        labeler.Func(LabelSetsFor),
 			restConfig:        &rest.Config{},
 		},
 		recorder: &record.FakeRecorder{},
@@ -328,10 +326,18 @@ func NewFakeOperator(ctx context.Context, options ...fakeOperatorOption) (*Opera
 	return op, nil
 }
 
-func buildFakeAPIIntersectionReconcilerThatReturns(result resolver.APIReconciliationResult) *fakes.FakeAPIIntersectionReconciler {
-	reconciler := &fakes.FakeAPIIntersectionReconciler{}
-	reconciler.ReconcileReturns(result)
-	return reconciler
+type fakeAPIIntersectionReconciler struct {
+	Result APIReconciliationResult
+}
+
+func (f fakeAPIIntersectionReconciler) Reconcile(resolvercache.APISet, OperatorGroupSurface, ...OperatorGroupSurface) APIReconciliationResult {
+	return f.Result
+}
+
+func buildFakeAPIIntersectionReconcilerThatReturns(result APIReconciliationResult) APIIntersectionReconciler {
+	return fakeAPIIntersectionReconciler{
+		Result: result,
+	}
 }
 
 func deployment(deploymentName, namespace, serviceAccountName string, templateAnnotations map[string]string) *appsv1.Deployment {
@@ -916,7 +922,7 @@ func TestTransitionCSV(t *testing.T) {
 		reason v1alpha1.ConditionReason
 	}
 	type operatorConfig struct {
-		apiReconciler resolver.APIIntersectionReconciler
+		apiReconciler APIIntersectionReconciler
 		apiLabeler    labeler.Labeler
 	}
 	type initial struct {
@@ -2573,7 +2579,7 @@ func TestTransitionCSV(t *testing.T) {
 						[]*apiextensionsv1.CustomResourceDefinition{},
 						v1alpha1.CSVPhaseSucceeded,
 					), defaultTemplateAnnotations), labels.Set{
-						resolver.APILabelKeyPrefix + apiHash: "provided",
+						APILabelKeyPrefix + apiHash: "provided",
 					}),
 					csvWithLabels(csvWithAnnotations(csv("csv1",
 						namespace,
@@ -2584,7 +2590,7 @@ func TestTransitionCSV(t *testing.T) {
 						[]*apiextensionsv1.CustomResourceDefinition{},
 						v1alpha1.CSVPhaseReplacing,
 					), defaultTemplateAnnotations), labels.Set{
-						resolver.APILabelKeyPrefix + apiHash: "provided",
+						APILabelKeyPrefix + apiHash: "provided",
 					}),
 					csvWithLabels(csvWithAnnotations(csv("csv2",
 						namespace,
@@ -2595,7 +2601,7 @@ func TestTransitionCSV(t *testing.T) {
 						[]*apiextensionsv1.CustomResourceDefinition{},
 						v1alpha1.CSVPhaseReplacing,
 					), defaultTemplateAnnotations), labels.Set{
-						resolver.APILabelKeyPrefix + apiHash: "provided",
+						APILabelKeyPrefix + apiHash: "provided",
 					}),
 				},
 				clientObjs: []runtime.Object{defaultOperatorGroup},
@@ -2777,7 +2783,7 @@ func TestTransitionCSV(t *testing.T) {
 		},
 		{
 			name:   "SingleCSVNoneToFailed/InterOperatorGroupOwnerConflict",
-			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(resolver.APIConflict)},
+			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(APIConflict)},
 			initial: initial{
 				csvs: []runtime.Object{
 					csvWithAnnotations(csv("csv1",
@@ -2800,7 +2806,7 @@ func TestTransitionCSV(t *testing.T) {
 		},
 		{
 			name:   "SingleCSVNoneToNone/AddAPIs",
-			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(resolver.AddAPIs)},
+			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(AddAPIs)},
 			initial: initial{
 				csvs: []runtime.Object{
 					csvWithAnnotations(csv("csv1",
@@ -2823,7 +2829,7 @@ func TestTransitionCSV(t *testing.T) {
 		},
 		{
 			name:   "SingleCSVNoneToNone/RemoveAPIs",
-			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(resolver.RemoveAPIs)},
+			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(RemoveAPIs)},
 			initial: initial{
 				csvs: []runtime.Object{
 					csvWithAnnotations(csv("csv1",
@@ -2846,7 +2852,7 @@ func TestTransitionCSV(t *testing.T) {
 		},
 		{
 			name:   "SingleCSVNoneToFailed/StaticOperatorGroup/AddAPIs",
-			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(resolver.AddAPIs)},
+			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(AddAPIs)},
 			initial: initial{
 				csvs: []runtime.Object{
 					csvWithAnnotations(csv("csv1",
@@ -2876,7 +2882,7 @@ func TestTransitionCSV(t *testing.T) {
 		},
 		{
 			name:   "SingleCSVNoneToFailed/StaticOperatorGroup/RemoveAPIs",
-			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(resolver.RemoveAPIs)},
+			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(RemoveAPIs)},
 			initial: initial{
 				csvs: []runtime.Object{
 					csvWithAnnotations(csv("csv1",
@@ -2906,7 +2912,7 @@ func TestTransitionCSV(t *testing.T) {
 		},
 		{
 			name:   "SingleCSVNoneToPending/StaticOperatorGroup/NoAPIConflict",
-			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(resolver.NoAPIConflict)},
+			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(NoAPIConflict)},
 			initial: initial{
 				csvs: []runtime.Object{
 					csvWithAnnotations(csv("csv1",
@@ -2936,7 +2942,7 @@ func TestTransitionCSV(t *testing.T) {
 		},
 		{
 			name:   "SingleCSVFailedToPending/InterOperatorGroupOwnerConflict/NoAPIConflict",
-			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(resolver.NoAPIConflict)},
+			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(NoAPIConflict)},
 			initial: initial{
 				csvs: []runtime.Object{
 					csvWithAnnotations(csvWithStatusReason(csv("csv1",
@@ -2959,7 +2965,7 @@ func TestTransitionCSV(t *testing.T) {
 		},
 		{
 			name:   "SingleCSVFailedToPending/StaticOperatorGroup/CannotModifyStaticOperatorGroupProvidedAPIs/NoAPIConflict",
-			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(resolver.NoAPIConflict)},
+			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(NoAPIConflict)},
 			initial: initial{
 				csvs: []runtime.Object{
 					csvWithAnnotations(csvWithStatusReason(csv("csv1",
@@ -2989,7 +2995,7 @@ func TestTransitionCSV(t *testing.T) {
 		},
 		{
 			name:   "SingleCSVFailedToFailed/InterOperatorGroupOwnerConflict/APIConflict",
-			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(resolver.APIConflict)},
+			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(APIConflict)},
 			initial: initial{
 				csvs: []runtime.Object{
 					csvWithAnnotations(csvWithStatusReason(csv("csv1",
@@ -3012,7 +3018,7 @@ func TestTransitionCSV(t *testing.T) {
 		},
 		{
 			name:   "SingleCSVFailedToFailed/StaticOperatorGroup/CannotModifyStaticOperatorGroupProvidedAPIs/AddAPIs",
-			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(resolver.AddAPIs)},
+			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(AddAPIs)},
 			initial: initial{
 				csvs: []runtime.Object{
 					csvWithAnnotations(csvWithStatusReason(csv("csv1",
@@ -3042,7 +3048,7 @@ func TestTransitionCSV(t *testing.T) {
 		},
 		{
 			name:   "SingleCSVFailedToFailed/StaticOperatorGroup/CannotModifyStaticOperatorGroupProvidedAPIs/RemoveAPIs",
-			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(resolver.RemoveAPIs)},
+			config: operatorConfig{apiReconciler: buildFakeAPIIntersectionReconcilerThatReturns(RemoveAPIs)},
 			initial: initial{
 				csvs: []runtime.Object{
 					csvWithAnnotations(csvWithStatusReason(csv("csv1",
@@ -3692,7 +3698,7 @@ func TestSyncOperatorGroups(t *testing.T) {
 		[]*apiextensionsv1.CustomResourceDefinition{crd},
 		[]*apiextensionsv1.CustomResourceDefinition{},
 		v1alpha1.CSVPhaseNone,
-	), labels.Set{resolver.APILabelKeyPrefix + "9f4c46c37bdff8d0": "provided"})
+	), labels.Set{APILabelKeyPrefix + "9f4c46c37bdff8d0": "provided"})
 
 	operatorCSV.Spec.InstallStrategy.StrategySpec.DeploymentSpecs[0].Spec.Template.Spec.Containers[0].Env = []corev1.EnvVar{{
 		Name:  "OPERATOR_CONDITION_NAME",
diff --git a/pkg/controller/registry/resolver/cache/operators_test.go b/pkg/controller/registry/resolver/cache/operators_test.go
index 5e08f8b08..cf46ad80f 100644
--- a/pkg/controller/registry/resolver/cache/operators_test.go
+++ b/pkg/controller/registry/resolver/cache/operators_test.go
@@ -736,30 +736,30 @@ func TestAPIMultiOwnerSet_PopAPIKey(t *testing.T) {
 		{
 			name: "OneApi/OneOwner",
 			s: map[opregistry.APIKey]OperatorSet{
-				{Group: "g", Version: "v", Kind: "k", Plural: "p"}: map[string]OperatorSurface{
-					"owner1": &Operator{Name: "op1"},
+				{Group: "g", Version: "v", Kind: "k", Plural: "p"}: map[string]*Operator{
+					"owner1": {Name: "op1"},
 				},
 			},
 		},
 		{
 			name: "OneApi/MultiOwner",
 			s: map[opregistry.APIKey]OperatorSet{
-				{Group: "g", Version: "v", Kind: "k", Plural: "p"}: map[string]OperatorSurface{
-					"owner1": &Operator{Name: "op1"},
-					"owner2": &Operator{Name: "op2"},
+				{Group: "g", Version: "v", Kind: "k", Plural: "p"}: map[string]*Operator{
+					"owner1": {Name: "op1"},
+					"owner2": {Name: "op2"},
 				},
 			},
 		},
 		{
 			name: "MultipleApi/MultiOwner",
 			s: map[opregistry.APIKey]OperatorSet{
-				{Group: "g", Version: "v", Kind: "k", Plural: "p"}: map[string]OperatorSurface{
-					"owner1": &Operator{Name: "op1"},
-					"owner2": &Operator{Name: "op2"},
+				{Group: "g", Version: "v", Kind: "k", Plural: "p"}: map[string]*Operator{
+					"owner1": {Name: "op1"},
+					"owner2": {Name: "op2"},
 				},
-				{Group: "g2", Version: "v2", Kind: "k2", Plural: "p2"}: map[string]OperatorSurface{
-					"owner1": &Operator{Name: "op1"},
-					"owner2": &Operator{Name: "op2"},
+				{Group: "g2", Version: "v2", Kind: "k2", Plural: "p2"}: map[string]*Operator{
+					"owner1": {Name: "op1"},
+					"owner2": {Name: "op2"},
 				},
 			},
 		},
@@ -796,42 +796,42 @@ func TestAPIMultiOwnerSet_PopAPIRequirers(t *testing.T) {
 		{
 			name: "OneApi/OneOwner",
 			s: map[opregistry.APIKey]OperatorSet{
-				{Group: "g", Version: "v", Kind: "k", Plural: "p"}: map[string]OperatorSurface{
-					"owner1": &Operator{Name: "op1"},
+				{Group: "g", Version: "v", Kind: "k", Plural: "p"}: map[string]*Operator{
+					"owner1": {Name: "op1"},
 				},
 			},
-			want: map[string]OperatorSurface{
-				"owner1": &Operator{Name: "op1"},
+			want: map[string]*Operator{
+				"owner1": {Name: "op1"},
 			},
 		},
 		{
 			name: "OneApi/MultiOwner",
 			s: map[opregistry.APIKey]OperatorSet{
-				{Group: "g", Version: "v", Kind: "k", Plural: "p"}: map[string]OperatorSurface{
-					"owner1": &Operator{Name: "op1"},
-					"owner2": &Operator{Name: "op2"},
+				{Group: "g", Version: "v", Kind: "k", Plural: "p"}: map[string]*Operator{
+					"owner1": {Name: "op1"},
+					"owner2": {Name: "op2"},
 				},
 			},
-			want: map[string]OperatorSurface{
-				"owner1": &Operator{Name: "op1"},
-				"owner2": &Operator{Name: "op2"},
+			want: map[string]*Operator{
+				"owner1": {Name: "op1"},
+				"owner2": {Name: "op2"},
 			},
 		},
 		{
 			name: "MultipleApi/MultiOwner",
 			s: map[opregistry.APIKey]OperatorSet{
-				{Group: "g", Version: "v", Kind: "k", Plural: "p"}: map[string]OperatorSurface{
-					"owner1": &Operator{Name: "op1"},
-					"owner2": &Operator{Name: "op2"},
+				{Group: "g", Version: "v", Kind: "k", Plural: "p"}: map[string]*Operator{
+					"owner1": {Name: "op1"},
+					"owner2": {Name: "op2"},
 				},
-				{Group: "g2", Version: "v2", Kind: "k2", Plural: "p2"}: map[string]OperatorSurface{
-					"owner1": &Operator{Name: "op1"},
-					"owner2": &Operator{Name: "op2"},
+				{Group: "g2", Version: "v2", Kind: "k2", Plural: "p2"}: map[string]*Operator{
+					"owner1": {Name: "op1"},
+					"owner2": {Name: "op2"},
 				},
 			},
-			want: map[string]OperatorSurface{
-				"owner1": &Operator{Name: "op1"},
-				"owner2": &Operator{Name: "op2"},
+			want: map[string]*Operator{
+				"owner1": {Name: "op1"},
+				"owner2": {Name: "op2"},
 			},
 		},
 	}
diff --git a/pkg/controller/registry/resolver/instrumented_resolver_test.go b/pkg/controller/registry/resolver/instrumented_resolver_test.go
index dac60b533..4b4c57fcf 100644
--- a/pkg/controller/registry/resolver/instrumented_resolver_test.go
+++ b/pkg/controller/registry/resolver/instrumented_resolver_test.go
@@ -2,10 +2,11 @@ package resolver
 
 import (
 	"errors"
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry"
 	"testing"
 	"time"
 
+	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry"
+
 	"github.com/operator-framework/api/pkg/operators/v1alpha1"
 	"github.com/stretchr/testify/require"
 )
@@ -19,14 +20,14 @@ const (
 type fakeResolverWithError struct{}
 type fakeResolverWithoutError struct{}
 
-func (r *fakeResolverWithError) ResolveSteps(namespace string, sourceQuerier SourceQuerier) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) {
+func (r *fakeResolverWithError) ResolveSteps(namespace string) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) {
 	return nil, nil, nil, errors.New("Fake error")
 }
 
 func (r *fakeResolverWithError) Expire(key registry.CatalogKey) {
 }
 
-func (r *fakeResolverWithoutError) ResolveSteps(namespace string, sourceQuerier SourceQuerier) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) {
+func (r *fakeResolverWithoutError) ResolveSteps(namespace string) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error) {
 	return nil, nil, nil, nil
 }
 
@@ -53,7 +54,7 @@ func TestInstrumentedResolverFailure(t *testing.T) {
 	}
 
 	instrumentedResolver := NewInstrumentedResolver(newFakeResolverWithError(), changeToSuccess, changeToFailure)
-	instrumentedResolver.ResolveSteps("", nil)
+	instrumentedResolver.ResolveSteps("")
 	require.Equal(t, len(result), 1)     // check that only one call was made to a change function
 	require.Equal(t, result[0], failure) // check that the call was made to changeToFailure function
 }
@@ -70,7 +71,7 @@ func TestInstrumentedResolverSuccess(t *testing.T) {
 	}
 
 	instrumentedResolver := NewInstrumentedResolver(newFakeResolverWithoutError(), changeToSuccess, changeToFailure)
-	instrumentedResolver.ResolveSteps("", nil)
+	instrumentedResolver.ResolveSteps("")
 	require.Equal(t, len(result), 1)     // check that only one call was made to a change function
 	require.Equal(t, result[0], success) // check that the call was made to changeToSuccess function
 }
diff --git a/pkg/controller/registry/resolver/resolver_test.go b/pkg/controller/registry/resolver/resolver_test.go
index fc9b3eb33..a686cbdcf 100644
--- a/pkg/controller/registry/resolver/resolver_test.go
+++ b/pkg/controller/registry/resolver/resolver_test.go
@@ -208,7 +208,7 @@ func TestSolveOperators_FindLatestVersion(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, 2, len(operators))
 	for _, op := range operators {
-		assert.Equal(t, "1.0.1", op.GetVersion().String())
+		assert.Equal(t, "1.0.1", op.Version.String())
 	}
 
 	expected := cache.OperatorSet{
@@ -286,7 +286,7 @@ func TestSolveOperators_FindLatestVersionWithDependencies(t *testing.T) {
 	}
 	for k := range expected {
 		require.NotNil(t, operators[k])
-		assert.EqualValues(t, k, operators[k].Identifier())
+		assert.EqualValues(t, k, operators[k].Name)
 	}
 }
 
@@ -362,7 +362,7 @@ func TestSolveOperators_FindLatestVersionWithNestedDependencies(t *testing.T) {
 	}
 	for k := range expected {
 		require.NotNil(t, operators[k])
-		assert.EqualValues(t, k, operators[k].Identifier())
+		assert.EqualValues(t, k, operators[k].Name)
 	}
 }
 
@@ -565,7 +565,7 @@ func TestSolveOperators_WithDependencies(t *testing.T) {
 	}
 	for k := range expected {
 		require.NotNil(t, operators[k])
-		assert.EqualValues(t, k, operators[k].Identifier())
+		assert.EqualValues(t, k, operators[k].Name)
 	}
 }
 
@@ -618,7 +618,7 @@ func TestSolveOperators_WithGVKDependencies(t *testing.T) {
 	assert.Equal(t, len(expected), len(operators))
 	for k := range expected {
 		require.NotNil(t, operators[k])
-		assert.EqualValues(t, k, operators[k].Identifier())
+		assert.EqualValues(t, k, operators[k].Name)
 	}
 }
 
@@ -679,7 +679,7 @@ func TestSolveOperators_WithLabelDependencies(t *testing.T) {
 	}
 	for k := range expected {
 		require.NotNil(t, operators[k])
-		assert.EqualValues(t, k, operators[k].Identifier())
+		assert.EqualValues(t, k, operators[k].Name)
 	}
 }
 
@@ -801,12 +801,12 @@ func TestSolveOperators_WithNestedGVKDependencies(t *testing.T) {
 	}
 	got := []string{}
 	for _, o := range operators {
-		got = append(got, o.Identifier())
+		got = append(got, o.Name)
 	}
 	for k := range expected {
 		assert.NotNil(t, operators[k], "did not find expected operator %s in results. have: %s", k, got)
 		if _, ok := operators[k]; ok {
-			assert.EqualValues(t, k, operators[k].Identifier())
+			assert.EqualValues(t, k, operators[k].Name)
 		}
 	}
 }
@@ -877,7 +877,7 @@ func TestSolveOperators_IgnoreUnsatisfiableDependencies(t *testing.T) {
 	assert.Equal(t, len(expected), len(operators))
 	for k := range expected {
 		require.NotNil(t, operators[k])
-		assert.EqualValues(t, k, operators[k].Identifier())
+		assert.EqualValues(t, k, operators[k].Name)
 	}
 }
 
@@ -1095,7 +1095,7 @@ func TestSolveOperators_SubscriptionlessOperatorsSatisfyDependencies(t *testing.
 	assert.Equal(t, len(expected), len(operators))
 	for k := range expected {
 		require.NotNil(t, operators[k])
-		assert.EqualValues(t, k, operators[k].Identifier())
+		assert.EqualValues(t, k, operators[k].Name)
 	}
 }
 
@@ -1189,7 +1189,7 @@ func TestSolveOperators_PackageCannotSelfSatisfy(t *testing.T) {
 	}
 	for k := range expected {
 		require.NotNil(t, operators[k])
-		assert.EqualValues(t, k, operators[k].Identifier())
+		assert.EqualValues(t, k, operators[k].Name)
 	}
 	assert.Equal(t, 3, len(operators))
 }
@@ -1276,11 +1276,11 @@ func TestSolveOperators_TransferApiOwnership(t *testing.T) {
 			csvs := make([]*v1alpha1.ClusterServiceVersion, 0)
 			for _, o := range operators {
 				var pkg, channel string
-				if b := o.GetBundle(); b != nil {
+				if b := o.Bundle; b != nil {
 					pkg = b.PackageName
 					channel = b.ChannelName
 				}
-				csvs = append(csvs, existingOperator(namespace, o.Identifier(), pkg, channel, o.GetReplaces(), o.GetProvidedAPIs(), o.GetRequiredAPIs(), nil, nil))
+				csvs = append(csvs, existingOperator(namespace, o.Name, pkg, channel, o.Replaces, o.ProvidedAPIs, o.RequiredAPIs, nil, nil))
 			}
 
 			var err error
@@ -1288,7 +1288,7 @@ func TestSolveOperators_TransferApiOwnership(t *testing.T) {
 			assert.NoError(t, err)
 			for k := range p.expected {
 				require.NotNil(t, operators[k])
-				assert.EqualValues(t, k, operators[k].Identifier())
+				assert.EqualValues(t, k, operators[k].Name)
 			}
 			assert.Equal(t, len(p.expected), len(operators))
 		})
diff --git a/pkg/controller/registry/resolver/step_resolver_test.go b/pkg/controller/registry/resolver/step_resolver_test.go
index 27225f556..eeed54fee 100644
--- a/pkg/controller/registry/resolver/step_resolver_test.go
+++ b/pkg/controller/registry/resolver/step_resolver_test.go
@@ -62,7 +62,6 @@ func TestResolver(t *testing.T) {
 	type resolverTest struct {
 		name             string
 		clusterState     []runtime.Object
-		querier          SourceQuerier
 		bundlesByCatalog map[registry.CatalogKey][]*api.Bundle
 		out              resolverTestOut
 	}
@@ -852,7 +851,7 @@ func TestResolver(t *testing.T) {
 			resolver := NewOperatorStepResolver(lister, clientFake, kClientFake, "", nil, log)
 			resolver.satResolver = satresolver
 
-			steps, lookups, subs, err := resolver.ResolveSteps(namespace, nil)
+			steps, lookups, subs, err := resolver.ResolveSteps(namespace)
 			if tt.out.solverError == nil {
 				if tt.out.errAssert == nil {
 					assert.NoError(t, err)
@@ -999,8 +998,7 @@ func TestNamespaceResolverRBAC(t *testing.T) {
 			}
 			resolver := NewOperatorStepResolver(lister, clientFake, kClientFake, "", nil, logrus.New())
 			resolver.satResolver = satresolver
-			querier := NewFakeSourceQuerier(map[registry.CatalogKey][]*api.Bundle{catalog: tt.bundlesInCatalog})
-			steps, _, subs, err := resolver.ResolveSteps(namespace, querier)
+			steps, _, subs, err := resolver.ResolveSteps(namespace)
 			require.Equal(t, tt.out.err, err)
 			RequireStepsEqual(t, expectedSteps, steps)
 			require.ElementsMatch(t, tt.out.subs, subs)
diff --git a/pkg/controller/registry/resolver/util_test.go b/pkg/controller/registry/resolver/util_test.go
index 533013a38..6586277b5 100644
--- a/pkg/controller/registry/resolver/util_test.go
+++ b/pkg/controller/registry/resolver/util_test.go
@@ -1,10 +1,7 @@
 package resolver
 
 import (
-	"context"
 	"encoding/json"
-	"fmt"
-	"strings"
 	"testing"
 
 	"github.com/operator-framework/operator-registry/pkg/api"
@@ -18,9 +15,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 
 	"github.com/operator-framework/api/pkg/operators/v1alpha1"
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache"
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/fakes"
 )
 
 // RequireStepsEqual is similar to require.ElementsMatch, but produces better error messages
@@ -305,132 +300,3 @@ func withReplaces(operator *cache.Operator, replaces string) *cache.Operator {
 	operator.Replaces = replaces
 	return operator
 }
-
-// NewFakeSourceQuerier builds a querier that talks to fake registry stubs for testing
-func NewFakeSourceQuerier(bundlesByCatalog map[registry.CatalogKey][]*api.Bundle) *NamespaceSourceQuerier {
-	sources := map[registry.CatalogKey]registry.ClientInterface{}
-	for catKey, bundles := range bundlesByCatalog {
-		source := &fakes.FakeClientInterface{}
-		source.GetBundleThatProvidesStub = func(ctx context.Context, groupOrName, version, kind string) (*api.Bundle, error) {
-			for _, b := range bundles {
-				apis := b.GetProvidedApis()
-				for _, api := range apis {
-					if api.Version == version && api.Kind == kind && strings.Contains(groupOrName, api.Group) && strings.Contains(groupOrName, api.Plural) {
-						return b, nil
-					}
-				}
-			}
-			return nil, fmt.Errorf("no bundle found")
-		}
-		// note: this only allows for one bundle per package/channel, which may be enough for tests
-		source.GetBundleInPackageChannelStub = func(ctx context.Context, packageName, channelName string) (*api.Bundle, error) {
-			for _, b := range bundles {
-				if b.ChannelName == channelName && b.PackageName == packageName {
-					return b, nil
-				}
-			}
-			return nil, fmt.Errorf("no bundle found")
-		}
-
-		source.GetBundleStub = func(ctx context.Context, packageName, channelName, csvName string) (*api.Bundle, error) {
-			for _, b := range bundles {
-				if b.ChannelName == channelName && b.PackageName == packageName && b.CsvName == csvName {
-					return b, nil
-				}
-			}
-			return nil, fmt.Errorf("no bundle found")
-		}
-
-		source.GetReplacementBundleInPackageChannelStub = func(ctx context.Context, bundleName, packageName, channelName string) (*api.Bundle, error) {
-			for _, b := range bundles {
-				if b.Replaces == bundleName && b.ChannelName == channelName && b.PackageName == packageName {
-					return b, nil
-				}
-			}
-
-			return nil, fmt.Errorf("no bundle found")
-		}
-
-		source.FindBundleThatProvidesStub = func(ctx context.Context, groupOrName, version, kind string, excludedPkgs map[string]struct{}) (*api.Bundle, error) {
-			bundles, ok := bundlesByCatalog[catKey]
-			if !ok {
-				return nil, fmt.Errorf("API (%s/%s/%s) not provided by a package in %s CatalogSource", groupOrName, version, kind, catKey)
-			}
-			sortedBundles := SortBundleInPackageChannel(bundles)
-			for k, v := range sortedBundles {
-				pkgname := getPkgName(k)
-				if _, ok := excludedPkgs[pkgname]; ok {
-					continue
-				}
-
-				for i := len(v) - 1; i >= 0; i-- {
-					b := v[i]
-					apis := b.GetProvidedApis()
-					for _, api := range apis {
-						if api.Version == version && api.Kind == kind && strings.Contains(groupOrName, api.Group) && strings.Contains(groupOrName, api.Plural) {
-							return b, nil
-						}
-					}
-				}
-			}
-			return nil, fmt.Errorf("no bundle found")
-		}
-
-		sources[catKey] = source
-	}
-	return NewNamespaceSourceQuerier(sources)
-}
-
-// SortBundleInPackageChannel will sort into map of package-channel key and list
-// sorted (oldest to latest version) of bundles as value
-func SortBundleInPackageChannel(bundles []*api.Bundle) map[string][]*api.Bundle {
-	sorted := map[string][]*api.Bundle{}
-	var initialReplaces string
-	for _, v := range bundles {
-		pkgChanKey := v.PackageName + "/" + v.ChannelName
-		sorted[pkgChanKey] = append(sorted[pkgChanKey], v)
-	}
-
-	for k, v := range sorted {
-		resorted := []*api.Bundle{}
-		bundleMap := map[string]*api.Bundle{}
-		// Find the first (oldest) bundle in upgrade graph
-		for _, bundle := range v {
-			csv, err := V1alpha1CSVFromBundle(bundle)
-			if err != nil {
-				initialReplaces = bundle.CsvName
-				resorted = append(resorted, bundle)
-				continue
-			}
-
-			if replaces := csv.Spec.Replaces; replaces == "" {
-				initialReplaces = bundle.CsvName
-				resorted = append(resorted, bundle)
-			} else {
-				bundleMap[replaces] = bundle
-			}
-		}
-		resorted = sortBundleInChannel(initialReplaces, bundleMap, resorted)
-		sorted[k] = resorted
-	}
-	return sorted
-}
-
-// sortBundleInChannel recursively sorts a list of bundles to form a update graph
-// of a specific channel. The first item in the returned list is the start
-// (oldest version) of the upgrade graph and the last item is the head
-// (latest version) of a channel
-func sortBundleInChannel(replaces string, replacedBundle map[string]*api.Bundle, updated []*api.Bundle) []*api.Bundle {
-	bundle, ok := replacedBundle[replaces]
-	if ok {
-		updated = append(updated, bundle)
-		return sortBundleInChannel(bundle.CsvName, replacedBundle, updated)
-	}
-	return updated
-}
-
-// getPkgName splits the package/channel string and return package name
-func getPkgName(pkgChan string) string {
-	s := strings.Split(pkgChan, "/")
-	return s[0]
-}
diff --git a/test/e2e/subscription_e2e_test.go b/test/e2e/subscription_e2e_test.go
index c1a0750ae..cb2183b0a 100644
--- a/test/e2e/subscription_e2e_test.go
+++ b/test/e2e/subscription_e2e_test.go
@@ -31,7 +31,6 @@ import (
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry"
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/projection"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/lib/comparison"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorclient"
@@ -219,7 +218,7 @@ var _ = Describe("Subscription", func() {
 		stableChannel := "stable"
 		mainCSV := newCSV(mainPackageStable, testNamespace, "", semver.MustParse("0.1.0-1556661347"), []apiextensions.CustomResourceDefinition{crd}, nil, nil)
 		updatedCSV := newCSV(updatedPackageStable, testNamespace, "", semver.MustParse("0.1.0-1556661832"), []apiextensions.CustomResourceDefinition{crd}, nil, nil)
-		updatedCSV.SetAnnotations(map[string]string{resolver.SkipPackageAnnotationKey: ">=0.1.0-1556661347 <0.1.0-1556661832"})
+		updatedCSV.SetAnnotations(map[string]string{"olm.skipRange": ">=0.1.0-1556661347 <0.1.0-1556661832"})
 
 		c := newKubeClient()
 		crc := newCRClient()