Repository: operator-framework/operator-lifecycle-manager
Pull request #1549 (2020-05-26 20:26:34)

Bug 1838054: fix(catalog): no operatorgroups in a namespace should be an error when resolving
<!--

Before making a PR, please read our contributing guidelines https://github.com/operator-framework/operator-lifecycle-manager/blob/master/CONTRIBUTING.MD

Note: Make sure your branch is rebased to the latest upstream master.

-->

**Description of the change:**
This is a 1-line fix plus tests, to avoid applying installplans when there is no operatorgroup in the namespace. 

There should be follow-up work to address the UX - this should probably fail earlier in the process with a message that users can understand (i.e. in status, on subscriptions, may an event)

**Motivation for the change:**
InstallPlans were creating service accounts with RBAC in namespaces that don't have operatorgroups.

**Reviewer Checklist**
- [ ] Implementation matches the proposed design, or proposal is updated to match implementation
- [ ] Sufficient unit test coverage 
- [ ] Sufficient end-to-end test coverage
- [ ] Docs updated or added to `/docs` 
- [ ] Commit messages sensible and descriptive


<!--

Note: If this PR is fixing an issue make sure to add a note saying:
Closes #<ISSUE_NUMBER>

-->


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

This pull-request has been approved by: *<a href="https://github.com/operator-framework/operator-lifecycle-manager/pull/1549#" title="Author self-approved">ecordell</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)~~ [ecordell]

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-robot: @ecordell: The following test **failed**, say `/retest` to rerun all failed tests:

Test name | Commit | Details | Rerun command
--- | --- | --- | ---
ci/prow/e2e-aws-console-olm | 8393444fd08cc264c4aaa48a87a2c28ca2789bd1 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-aws-console-olm/2959) | `/test e2e-aws-console-olm`

[Full PR test history](https://prow.svc.ci.openshift.org/pr-history?org=operator-framework&repo=operator-lifecycle-manager&pr=1549). [Your PR dashboard](https://prow.svc.ci.openshift.org/pr?query=is:pr+state:open+author:ecordell). Please help us cut down on flakes by [linking to](https://github.com/kubernetes/community/blob/master/contributors/devel/flaky-tests.md#filing-issues-for-flaky-tests) an [open issue](https://github.com/operator-framework/operator-lifecycle-manager/issues?q=is:issue+is:open) when you hit one in your PR.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes/test-infra](https://github.com/kubernetes/test-infra/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->
openshift-ci-robot: @ecordell: The following tests **failed**, say `/retest` to rerun all failed tests:

Test name | Commit | Details | Rerun command
--- | --- | --- | ---
ci/prow/e2e-aws-console-olm | 8393444fd08cc264c4aaa48a87a2c28ca2789bd1 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-aws-console-olm/2959) | `/test e2e-aws-console-olm`
ci/prow/e2e-gcp | 8393444fd08cc264c4aaa48a87a2c28ca2789bd1 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-gcp/1831) | `/test e2e-gcp`

[Full PR test history](https://prow.svc.ci.openshift.org/pr-history?org=operator-framework&repo=operator-lifecycle-manager&pr=1549). [Your PR dashboard](https://prow.svc.ci.openshift.org/pr?query=is:pr+state:open+author:ecordell). Please help us cut down on flakes by [linking to](https://github.com/kubernetes/community/blob/master/contributors/devel/flaky-tests.md#filing-issues-for-flaky-tests) an [open issue](https://github.com/operator-framework/operator-lifecycle-manager/issues?q=is:issue+is:open) when you hit one in your PR.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes/test-infra](https://github.com/kubernetes/test-infra/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->
openshift-ci-robot: @ecordell: The following tests **failed**, say `/retest` to rerun all failed tests:

Test name | Commit | Details | Rerun command
--- | --- | --- | ---
ci/prow/e2e-aws-console-olm | 8393444fd08cc264c4aaa48a87a2c28ca2789bd1 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-aws-console-olm/2959) | `/test e2e-aws-console-olm`
ci/prow/e2e-gcp | 8393444fd08cc264c4aaa48a87a2c28ca2789bd1 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-gcp/1831) | `/test e2e-gcp`
ci/prow/e2e-gcp-upgrade | 0262af03af773ca260a5986237f9e99ca4ed0b29 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-gcp-upgrade/1640) | `/test e2e-gcp-upgrade`

[Full PR test history](https://prow.svc.ci.openshift.org/pr-history?org=operator-framework&repo=operator-lifecycle-manager&pr=1549). [Your PR dashboard](https://prow.svc.ci.openshift.org/pr?query=is:pr+state:open+author:ecordell). Please help us cut down on flakes by [linking to](https://github.com/kubernetes/community/blob/master/contributors/devel/flaky-tests.md#filing-issues-for-flaky-tests) an [open issue](https://github.com/operator-framework/operator-lifecycle-manager/issues?q=is:issue+is:open) when you hit one in your PR.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes/test-infra](https://github.com/kubernetes/test-infra/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->
openshift-ci-robot: @ecordell: The following tests **failed**, say `/retest` to rerun all failed tests:

Test name | Commit | Details | Rerun command
--- | --- | --- | ---
ci/prow/e2e-aws-console-olm | 8393444fd08cc264c4aaa48a87a2c28ca2789bd1 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-aws-console-olm/2959) | `/test e2e-aws-console-olm`
ci/prow/e2e-gcp-upgrade | 0262af03af773ca260a5986237f9e99ca4ed0b29 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-gcp-upgrade/1640) | `/test e2e-gcp-upgrade`
ci/prow/e2e-gcp | 0262af03af773ca260a5986237f9e99ca4ed0b29 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-gcp/1838) | `/test e2e-gcp`

[Full PR test history](https://prow.svc.ci.openshift.org/pr-history?org=operator-framework&repo=operator-lifecycle-manager&pr=1549). [Your PR dashboard](https://prow.svc.ci.openshift.org/pr?query=is:pr+state:open+author:ecordell). Please help us cut down on flakes by [linking to](https://github.com/kubernetes/community/blob/master/contributors/devel/flaky-tests.md#filing-issues-for-flaky-tests) an [open issue](https://github.com/operator-framework/operator-lifecycle-manager/issues?q=is:issue+is:open) when you hit one in your PR.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes/test-infra](https://github.com/kubernetes/test-infra/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->
openshift-ci-robot: @ecordell: The following tests **failed**, say `/retest` to rerun all failed tests:

Test name | Commit | Details | Rerun command
--- | --- | --- | ---
ci/prow/e2e-aws-console-olm | 8393444fd08cc264c4aaa48a87a2c28ca2789bd1 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-aws-console-olm/2959) | `/test e2e-aws-console-olm`
ci/prow/e2e-gcp-upgrade | 0262af03af773ca260a5986237f9e99ca4ed0b29 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-gcp-upgrade/1640) | `/test e2e-gcp-upgrade`
ci/prow/e2e-gcp | 0262af03af773ca260a5986237f9e99ca4ed0b29 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-gcp/1838) | `/test e2e-gcp`
ci/prow/e2e-aws-olm | 0262af03af773ca260a5986237f9e99ca4ed0b29 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-aws-olm/5537) | `/test e2e-aws-olm`

[Full PR test history](https://prow.svc.ci.openshift.org/pr-history?org=operator-framework&repo=operator-lifecycle-manager&pr=1549). [Your PR dashboard](https://prow.svc.ci.openshift.org/pr?query=is:pr+state:open+author:ecordell). Please help us cut down on flakes by [linking to](https://github.com/kubernetes/community/blob/master/contributors/devel/flaky-tests.md#filing-issues-for-flaky-tests) an [open issue](https://github.com/operator-framework/operator-lifecycle-manager/issues?q=is:issue+is:open) when you hit one in your PR.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes/test-infra](https://github.com/kubernetes/test-infra/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->
openshift-ci-robot: @ecordell: The following tests **failed**, say `/retest` to rerun all failed tests:

Test name | Commit | Details | Rerun command
--- | --- | --- | ---
ci/prow/e2e-gcp-upgrade | 0262af03af773ca260a5986237f9e99ca4ed0b29 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-gcp-upgrade/1640) | `/test e2e-gcp-upgrade`
ci/prow/e2e-gcp | 0262af03af773ca260a5986237f9e99ca4ed0b29 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-gcp/1838) | `/test e2e-gcp`
ci/prow/e2e-aws-olm | 0262af03af773ca260a5986237f9e99ca4ed0b29 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-aws-olm/5537) | `/test e2e-aws-olm`
ci/prow/e2e-aws-console-olm | 0262af03af773ca260a5986237f9e99ca4ed0b29 | [link](https://prow.svc.ci.openshift.org/view/gcs/origin-ci-test/pr-logs/pull/operator-framework_operator-lifecycle-manager/1549/pull-ci-operator-framework-operator-lifecycle-manager-master-e2e-aws-console-olm/2966) | `/test e2e-aws-console-olm`

[Full PR test history](https://prow.svc.ci.openshift.org/pr-history?org=operator-framework&repo=operator-lifecycle-manager&pr=1549). [Your PR dashboard](https://prow.svc.ci.openshift.org/pr?query=is:pr+state:open+author:ecordell). Please help us cut down on flakes by [linking to](https://github.com/kubernetes/community/blob/master/contributors/devel/flaky-tests.md#filing-issues-for-flaky-tests) an [open issue](https://github.com/operator-framework/operator-lifecycle-manager/issues?q=is:issue+is:open) when you hit one in your PR.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes/test-infra](https://github.com/kubernetes/test-infra/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->
openshift-ci-robot: @ecordell: This pull request references [Bugzilla bug 1838054](https://bugzilla.redhat.com/show_bug.cgi?id=1838054), which is valid. The bug has been moved to the POST state. The bug has been updated to refer to the pull request using the external bug tracker.

<details><summary>3 validation(s) were run on this bug</summary>

* bug is open, matching expected state (open)
* bug target release (4.5.0) matches configured target release for branch (4.5.0)
* bug is in the state ASSIGNED, which is one of the valid states (NEW, ASSIGNED, ON_DEV, POST, POST)</details>

<details>

In response to [this](https://github.com/operator-framework/operator-lifecycle-manager/pull/1549):

>Bug 1838054: fix(catalog): no operatorgroups in a namespace should be an error whe…


Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes/test-infra](https://github.com/kubernetes/test-infra/issues/new?title=Prow%20issue:) repository.
</details>
openshift-ci-robot: @ecordell: This pull request references [Bugzilla bug 1838054](https://bugzilla.redhat.com/show_bug.cgi?id=1838054), which is valid.

<details><summary>3 validation(s) were run on this bug</summary>

* bug is open, matching expected state (open)
* bug target release (4.5.0) matches configured target release for branch (4.5.0)
* bug is in the state POST, which is one of the valid states (NEW, ASSIGNED, ON_DEV, POST, POST)</details>

<details>

In response to [this](https://github.com/operator-framework/operator-lifecycle-manager/pull/1549):

>Bug 1838054: fix(catalog): no operatorgroups in a namespace should be an error when resolving


Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes/test-infra](https://github.com/kubernetes/test-infra/issues/new?title=Prow%20issue:) repository.
</details>
Bowenislandsong: /lgtm 
/hold waiting on a second review.

Patch:
diff --git a/pkg/controller/operators/catalog/operator.go b/pkg/controller/operators/catalog/operator.go
index 3ed6d0562..dedbef13b 100644
--- a/pkg/controller/operators/catalog/operator.go
+++ b/pkg/controller/operators/catalog/operator.go
@@ -1170,6 +1170,28 @@ func (o *Operator) syncInstallPlans(obj interface{}) (syncError error) {
 		return
 	}
 
+	querier := o.serviceAccountQuerier.NamespaceQuerier(plan.GetNamespace())
+	ref, err := querier()
+	if err != nil {
+		syncError = fmt.Errorf("attenuated service account query failed - %v", err)
+		return
+	}
+
+	if ref != nil {
+		out := plan.DeepCopy()
+		out.Status.AttenuatedServiceAccountRef = ref
+
+		if !reflect.DeepEqual(plan, out) {
+			if _, updateErr := o.client.OperatorsV1alpha1().InstallPlans(out.GetNamespace()).UpdateStatus(context.TODO(), out, metav1.UpdateOptions{}); updateErr != nil {
+				syncError = fmt.Errorf("failed to attach attenuated ServiceAccount to status - %v", updateErr)
+				return
+			}
+
+			logger.WithField("attenuated-sa", ref.Name).Info("successfully attached attenuated ServiceAccount to status")
+			return
+		}
+	}
+
 	// Attempt to unpack bundles before installing
 	// Note: This should probably use the attenuated client to prevent users from resolving resources they otherwise don't have access to.
 	if len(plan.Status.BundleLookups) > 0 {
@@ -1201,28 +1223,6 @@ func (o *Operator) syncInstallPlans(obj interface{}) (syncError error) {
 		}
 	}
 
-	querier := o.serviceAccountQuerier.NamespaceQuerier(plan.GetNamespace())
-	ref, err := querier()
-	if err != nil {
-		syncError = fmt.Errorf("attenuated service account query failed - %v", err)
-		return
-	}
-
-	if ref != nil {
-		out := plan.DeepCopy()
-		out.Status.AttenuatedServiceAccountRef = ref
-
-		if !reflect.DeepEqual(plan, out) {
-			if _, updateErr := o.client.OperatorsV1alpha1().InstallPlans(out.GetNamespace()).UpdateStatus(context.TODO(), out, metav1.UpdateOptions{}); updateErr != nil {
-				syncError = fmt.Errorf("failed to attach attenuated ServiceAccount to status - %v", updateErr)
-				return
-			}
-
-			logger.WithField("attenuated-sa", ref.Name).Info("successfully attached attenuated ServiceAccount to status")
-			return
-		}
-	}
-
 	outInstallPlan, syncError := transitionInstallPlanState(logger.Logger, o, *plan, o.now())
 
 	if syncError != nil {
diff --git a/pkg/controller/operators/olm/operatorgroup.go b/pkg/controller/operators/olm/operatorgroup.go
index 2f1040eac..8b9843353 100644
--- a/pkg/controller/operators/olm/operatorgroup.go
+++ b/pkg/controller/operators/olm/operatorgroup.go
@@ -100,7 +100,7 @@ func (a *Operator) syncOperatorGroups(obj interface{}) error {
 
 	if namespacesChanged(targetNamespaces, op.Status.Namespaces) {
 		logger.Debug("OperatorGroup namespaces change detected")
-		outOfSyncNamespaces := namespacesAddedOrRemoved(op.Status.Namespaces, targetNamespaces)
+		outOfSyncNamespaces := namespacesAddedOrRemoved(op.Spec.TargetNamespaces, op.Status.Namespaces)
 
 		// Update operatorgroup target namespace selection
 		logger.WithField("targets", targetNamespaces).Debug("namespace change detected")
diff --git a/pkg/controller/registry/grpc/source.go b/pkg/controller/registry/grpc/source.go
index 0fb781877..3926cc3ac 100644
--- a/pkg/controller/registry/grpc/source.go
+++ b/pkg/controller/registry/grpc/source.go
@@ -9,8 +9,8 @@ import (
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/connectivity"
 
-	"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-registry/pkg/client"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
@@ -190,8 +190,8 @@ func (s *SourceStore) Remove(key resolver.CatalogKey) error {
 	return source.Conn.Close()
 }
 
-func (s *SourceStore) AsClients(namespaces ...string) map[resolver.CatalogKey]registry.ClientInterface {
-	refs := map[resolver.CatalogKey]registry.ClientInterface{}
+func (s *SourceStore) AsClients(namespaces ...string) map[resolver.CatalogKey]client.Interface {
+	refs := map[resolver.CatalogKey]client.Interface{}
 	s.sourcesLock.RLock()
 	defer s.sourcesLock.RUnlock()
 	for key, source := range s.sources {
@@ -200,7 +200,7 @@ func (s *SourceStore) AsClients(namespaces ...string) map[resolver.CatalogKey]re
 		}
 		for _, namespace := range namespaces {
 			if key.Namespace == namespace {
-				refs[key] = registry.NewClientFromConn(source.Conn)
+				refs[key] = client.NewClientFromConn(source.Conn)
 			}
 		}
 	}
diff --git a/pkg/controller/registry/registry_client.go b/pkg/controller/registry/registry_client.go
deleted file mode 100644
index 9fe3ef9bc..000000000
--- a/pkg/controller/registry/registry_client.go
+++ /dev/null
@@ -1,121 +0,0 @@
-//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -o resolver/fakes/fake_registry_client_interface.go . ClientInterface
-package registry
-
-import (
-	"context"
-	"fmt"
-	"io"
-
-	"google.golang.org/grpc"
-
-	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"
-)
-
-// ChannelEntryStream interface
-type ChannelEntryStream interface {
-	Recv() (*registryapi.ChannelEntry, error)
-}
-
-// ClientInterface that extends client.Interface
-type ClientInterface interface {
-	client.Interface
-	FindBundleThatProvides(ctx context.Context, group, version, kind, excludedPkgName string) (*registryapi.Bundle, error)
-	GetLatestChannelEntriesThatProvide(ctx context.Context, group, version, kind string) (*ChannelEntryIterator, error)
-}
-
-// ChannelEntryIterator struct
-type ChannelEntryIterator struct {
-	stream ChannelEntryStream
-	error  error
-}
-
-// NewChannelEntryIterator returns a new ChannelEntryIterator
-func NewChannelEntryIterator(stream ChannelEntryStream) *ChannelEntryIterator {
-	return &ChannelEntryIterator{stream: stream}
-}
-
-// Next returns the next Channel Entry in the grpc stream
-func (ceit *ChannelEntryIterator) Next() *registryapi.ChannelEntry {
-	if ceit.error != nil {
-		return nil
-	}
-	next, err := ceit.stream.Recv()
-	if err == io.EOF {
-		return nil
-	}
-	if err != nil {
-		ceit.error = err
-	}
-	return next
-}
-
-func (ceit *ChannelEntryIterator) Error() error {
-	return ceit.error
-}
-
-// Client struct with a registry client embedded
-type Client struct {
-	*client.Client
-}
-
-// NewClientFromConn returns the next Channel Entry in the grpc stream
-func NewClientFromConn(conn *grpc.ClientConn) *Client {
-	return &Client{
-		Client: client.NewClientFromConn(conn),
-	}
-}
-
-var _ ClientInterface = &Client{}
-
-// GetLatestChannelEntriesThatProvide uses registry client to get a list of
-// latest channel entries that provide the requested API (via an iterator)
-func (rc *Client) GetLatestChannelEntriesThatProvide(ctx context.Context, group, version, kind string) (*ChannelEntryIterator, error) {
-	stream, err := rc.Client.Registry.GetLatestChannelEntriesThatProvide(ctx, &registryapi.GetLatestProvidersRequest{Group: group, Version: version, Kind: kind})
-	if err != nil {
-		return nil, err
-	}
-	return NewChannelEntryIterator(stream), nil
-}
-
-// FindBundleThatProvides returns a bundle that provides the request API and
-// doesn't belong to the provided package
-func (rc *Client) FindBundleThatProvides(ctx context.Context, group, version, kind, excludedPkgName string) (*registryapi.Bundle, error) {
-	it, err := rc.GetLatestChannelEntriesThatProvide(ctx, group, version, kind)
-	if err != nil {
-		return nil, err
-	}
-	entry := rc.filterChannelEntries(it, excludedPkgName)
-	if entry == nil {
-		return nil, fmt.Errorf("Unable to find a channel entry which doesn't belong to package %s", excludedPkgName)
-	}
-	bundle, err := rc.Client.Registry.GetBundle(ctx, &registryapi.GetBundleRequest{PkgName: entry.PackageName, ChannelName: entry.ChannelName, CsvName: entry.BundleName})
-	if err != nil {
-		return nil, err
-	}
-	return bundle, nil
-}
-
-// FilterChannelEntries filters out a channel entries that provide the requested
-// API and come from the same package with original operator and returns the
-// first entry on the list
-func (rc *Client) filterChannelEntries(it *ChannelEntryIterator, excludedPkgName string) *opregistry.ChannelEntry {
-	var entries []*opregistry.ChannelEntry
-	for e := it.Next(); e != nil; e = it.Next() {
-		if e.PackageName != excludedPkgName {
-			entry := &opregistry.ChannelEntry{
-				PackageName: e.PackageName,
-				ChannelName: e.ChannelName,
-				BundleName:  e.BundleName,
-				Replaces:    e.Replaces,
-			}
-			entries = append(entries, entry)
-		}
-	}
-
-	if entries != nil {
-		return entries[0]
-	}
-	return nil
-}
diff --git a/pkg/controller/registry/resolver/evolver.go b/pkg/controller/registry/resolver/evolver.go
index 32cbd2db8..95099e13b 100644
--- a/pkg/controller/registry/resolver/evolver.go
+++ b/pkg/controller/registry/resolver/evolver.go
@@ -134,7 +134,7 @@ func (e *NamespaceGenerationEvolver) queryForRequiredAPIs() error {
 		}
 
 		// attempt to find a bundle that provides that api
-		if bundle, key, err := e.querier.FindProvider(*api, initialSource.Catalog, initialSource.Package); err == nil {
+		if bundle, key, err := e.querier.FindProvider(*api, initialSource.Catalog); err == nil {
 			// add a bundle that provides the api to the generation
 			o, err := NewOperatorFromBundle(bundle, "", *key)
 			if err != nil {
diff --git a/pkg/controller/registry/resolver/fakes/fake_registry_client.go b/pkg/controller/registry/resolver/fakes/fake_registry_client.go
index ff5b4119a..1afca0637 100644
--- a/pkg/controller/registry/resolver/fakes/fake_registry_client.go
+++ b/pkg/controller/registry/resolver/fakes/fake_registry_client.go
@@ -4,18 +4,30 @@ package fakes
 import (
 	"context"
 	"sync"
+	"time"
 
 	"github.com/operator-framework/operator-registry/pkg/api"
-	"google.golang.org/grpc"
+	"github.com/operator-framework/operator-registry/pkg/client"
 )
 
-type FakeRegistryClient struct {
-	GetBundleStub        func(context.Context, *api.GetBundleRequest, ...grpc.CallOption) (*api.Bundle, error)
+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 *api.GetBundleRequest
-		arg3 []grpc.CallOption
+		arg2 string
+		arg3 string
+		arg4 string
 	}
 	getBundleReturns struct {
 		result1 *api.Bundle
@@ -25,157 +37,149 @@ type FakeRegistryClient struct {
 		result1 *api.Bundle
 		result2 error
 	}
-	GetBundleForChannelStub        func(context.Context, *api.GetBundleInChannelRequest, ...grpc.CallOption) (*api.Bundle, error)
-	getBundleForChannelMutex       sync.RWMutex
-	getBundleForChannelArgsForCall []struct {
+	GetBundleInPackageChannelStub        func(context.Context, string, string) (*api.Bundle, error)
+	getBundleInPackageChannelMutex       sync.RWMutex
+	getBundleInPackageChannelArgsForCall []struct {
 		arg1 context.Context
-		arg2 *api.GetBundleInChannelRequest
-		arg3 []grpc.CallOption
+		arg2 string
+		arg3 string
 	}
-	getBundleForChannelReturns struct {
+	getBundleInPackageChannelReturns struct {
 		result1 *api.Bundle
 		result2 error
 	}
-	getBundleForChannelReturnsOnCall map[int]struct {
+	getBundleInPackageChannelReturnsOnCall map[int]struct {
 		result1 *api.Bundle
 		result2 error
 	}
-	GetBundleThatReplacesStub        func(context.Context, *api.GetReplacementRequest, ...grpc.CallOption) (*api.Bundle, error)
-	getBundleThatReplacesMutex       sync.RWMutex
-	getBundleThatReplacesArgsForCall []struct {
+	GetBundleThatProvidesStub        func(context.Context, string, string, string) (*api.Bundle, error)
+	getBundleThatProvidesMutex       sync.RWMutex
+	getBundleThatProvidesArgsForCall []struct {
 		arg1 context.Context
-		arg2 *api.GetReplacementRequest
-		arg3 []grpc.CallOption
+		arg2 string
+		arg3 string
+		arg4 string
 	}
-	getBundleThatReplacesReturns struct {
+	getBundleThatProvidesReturns struct {
 		result1 *api.Bundle
 		result2 error
 	}
-	getBundleThatReplacesReturnsOnCall map[int]struct {
+	getBundleThatProvidesReturnsOnCall map[int]struct {
 		result1 *api.Bundle
 		result2 error
 	}
-	GetChannelEntriesThatProvideStub        func(context.Context, *api.GetAllProvidersRequest, ...grpc.CallOption) (api.Registry_GetChannelEntriesThatProvideClient, error)
-	getChannelEntriesThatProvideMutex       sync.RWMutex
-	getChannelEntriesThatProvideArgsForCall []struct {
-		arg1 context.Context
-		arg2 *api.GetAllProvidersRequest
-		arg3 []grpc.CallOption
-	}
-	getChannelEntriesThatProvideReturns struct {
-		result1 api.Registry_GetChannelEntriesThatProvideClient
-		result2 error
-	}
-	getChannelEntriesThatProvideReturnsOnCall map[int]struct {
-		result1 api.Registry_GetChannelEntriesThatProvideClient
-		result2 error
-	}
-	GetChannelEntriesThatReplaceStub        func(context.Context, *api.GetAllReplacementsRequest, ...grpc.CallOption) (api.Registry_GetChannelEntriesThatReplaceClient, error)
-	getChannelEntriesThatReplaceMutex       sync.RWMutex
-	getChannelEntriesThatReplaceArgsForCall []struct {
-		arg1 context.Context
-		arg2 *api.GetAllReplacementsRequest
-		arg3 []grpc.CallOption
-	}
-	getChannelEntriesThatReplaceReturns struct {
-		result1 api.Registry_GetChannelEntriesThatReplaceClient
-		result2 error
-	}
-	getChannelEntriesThatReplaceReturnsOnCall map[int]struct {
-		result1 api.Registry_GetChannelEntriesThatReplaceClient
-		result2 error
-	}
-	GetDefaultBundleThatProvidesStub        func(context.Context, *api.GetDefaultProviderRequest, ...grpc.CallOption) (*api.Bundle, error)
-	getDefaultBundleThatProvidesMutex       sync.RWMutex
-	getDefaultBundleThatProvidesArgsForCall []struct {
+	GetReplacementBundleInPackageChannelStub        func(context.Context, string, string, string) (*api.Bundle, error)
+	getReplacementBundleInPackageChannelMutex       sync.RWMutex
+	getReplacementBundleInPackageChannelArgsForCall []struct {
 		arg1 context.Context
-		arg2 *api.GetDefaultProviderRequest
-		arg3 []grpc.CallOption
+		arg2 string
+		arg3 string
+		arg4 string
 	}
-	getDefaultBundleThatProvidesReturns struct {
+	getReplacementBundleInPackageChannelReturns struct {
 		result1 *api.Bundle
 		result2 error
 	}
-	getDefaultBundleThatProvidesReturnsOnCall map[int]struct {
+	getReplacementBundleInPackageChannelReturnsOnCall map[int]struct {
 		result1 *api.Bundle
 		result2 error
 	}
-	GetLatestChannelEntriesThatProvideStub        func(context.Context, *api.GetLatestProvidersRequest, ...grpc.CallOption) (api.Registry_GetLatestChannelEntriesThatProvideClient, error)
-	getLatestChannelEntriesThatProvideMutex       sync.RWMutex
-	getLatestChannelEntriesThatProvideArgsForCall []struct {
-		arg1 context.Context
-		arg2 *api.GetLatestProvidersRequest
-		arg3 []grpc.CallOption
-	}
-	getLatestChannelEntriesThatProvideReturns struct {
-		result1 api.Registry_GetLatestChannelEntriesThatProvideClient
-		result2 error
-	}
-	getLatestChannelEntriesThatProvideReturnsOnCall map[int]struct {
-		result1 api.Registry_GetLatestChannelEntriesThatProvideClient
-		result2 error
-	}
-	GetPackageStub        func(context.Context, *api.GetPackageRequest, ...grpc.CallOption) (*api.Package, error)
-	getPackageMutex       sync.RWMutex
-	getPackageArgsForCall []struct {
+	HealthCheckStub        func(context.Context, time.Duration) (bool, error)
+	healthCheckMutex       sync.RWMutex
+	healthCheckArgsForCall []struct {
 		arg1 context.Context
-		arg2 *api.GetPackageRequest
-		arg3 []grpc.CallOption
+		arg2 time.Duration
 	}
-	getPackageReturns struct {
-		result1 *api.Package
+	healthCheckReturns struct {
+		result1 bool
 		result2 error
 	}
-	getPackageReturnsOnCall map[int]struct {
-		result1 *api.Package
+	healthCheckReturnsOnCall map[int]struct {
+		result1 bool
 		result2 error
 	}
-	ListBundlesStub        func(context.Context, *api.ListBundlesRequest, ...grpc.CallOption) (api.Registry_ListBundlesClient, error)
+	ListBundlesStub        func(context.Context) (*client.BundleIterator, error)
 	listBundlesMutex       sync.RWMutex
 	listBundlesArgsForCall []struct {
 		arg1 context.Context
-		arg2 *api.ListBundlesRequest
-		arg3 []grpc.CallOption
 	}
 	listBundlesReturns struct {
-		result1 api.Registry_ListBundlesClient
+		result1 *client.BundleIterator
 		result2 error
 	}
 	listBundlesReturnsOnCall map[int]struct {
-		result1 api.Registry_ListBundlesClient
+		result1 *client.BundleIterator
 		result2 error
 	}
-	ListPackagesStub        func(context.Context, *api.ListPackageRequest, ...grpc.CallOption) (api.Registry_ListPackagesClient, error)
-	listPackagesMutex       sync.RWMutex
-	listPackagesArgsForCall []struct {
-		arg1 context.Context
-		arg2 *api.ListPackageRequest
-		arg3 []grpc.CallOption
+	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()
 	}
-	listPackagesReturns struct {
-		result1 api.Registry_ListPackagesClient
-		result2 error
+	if specificReturn {
+		return ret.result1
 	}
-	listPackagesReturnsOnCall map[int]struct {
-		result1 api.Registry_ListPackagesClient
-		result2 error
+	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
+		})
 	}
-	invocations      map[string][][]interface{}
-	invocationsMutex sync.RWMutex
+	fake.closeReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
 }
 
-func (fake *FakeRegistryClient) GetBundle(arg1 context.Context, arg2 *api.GetBundleRequest, arg3 ...grpc.CallOption) (*api.Bundle, error) {
+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 *api.GetBundleRequest
-		arg3 []grpc.CallOption
-	}{arg1, arg2, arg3})
-	fake.recordInvocation("GetBundle", []interface{}{arg1, arg2, arg3})
+		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...)
+		return fake.GetBundleStub(arg1, arg2, arg3, arg4)
 	}
 	if specificReturn {
 		return ret.result1, ret.result2
@@ -184,26 +188,26 @@ func (fake *FakeRegistryClient) GetBundle(arg1 context.Context, arg2 *api.GetBun
 	return fakeReturns.result1, fakeReturns.result2
 }
 
-func (fake *FakeRegistryClient) GetBundleCallCount() int {
+func (fake *FakeInterface) GetBundleCallCount() int {
 	fake.getBundleMutex.RLock()
 	defer fake.getBundleMutex.RUnlock()
 	return len(fake.getBundleArgsForCall)
 }
 
-func (fake *FakeRegistryClient) GetBundleCalls(stub func(context.Context, *api.GetBundleRequest, ...grpc.CallOption) (*api.Bundle, error)) {
+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 *FakeRegistryClient) GetBundleArgsForCall(i int) (context.Context, *api.GetBundleRequest, []grpc.CallOption) {
+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
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
 }
 
-func (fake *FakeRegistryClient) GetBundleReturns(result1 *api.Bundle, result2 error) {
+func (fake *FakeInterface) GetBundleReturns(result1 *api.Bundle, result2 error) {
 	fake.getBundleMutex.Lock()
 	defer fake.getBundleMutex.Unlock()
 	fake.GetBundleStub = nil
@@ -213,7 +217,7 @@ func (fake *FakeRegistryClient) GetBundleReturns(result1 *api.Bundle, result2 er
 	}{result1, result2}
 }
 
-func (fake *FakeRegistryClient) GetBundleReturnsOnCall(i int, result1 *api.Bundle, result2 error) {
+func (fake *FakeInterface) GetBundleReturnsOnCall(i int, result1 *api.Bundle, result2 error) {
 	fake.getBundleMutex.Lock()
 	defer fake.getBundleMutex.Unlock()
 	fake.GetBundleStub = nil
@@ -229,473 +233,277 @@ func (fake *FakeRegistryClient) GetBundleReturnsOnCall(i int, result1 *api.Bundl
 	}{result1, result2}
 }
 
-func (fake *FakeRegistryClient) GetBundleForChannel(arg1 context.Context, arg2 *api.GetBundleInChannelRequest, arg3 ...grpc.CallOption) (*api.Bundle, error) {
-	fake.getBundleForChannelMutex.Lock()
-	ret, specificReturn := fake.getBundleForChannelReturnsOnCall[len(fake.getBundleForChannelArgsForCall)]
-	fake.getBundleForChannelArgsForCall = append(fake.getBundleForChannelArgsForCall, struct {
+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 *api.GetBundleInChannelRequest
-		arg3 []grpc.CallOption
+		arg2 string
+		arg3 string
 	}{arg1, arg2, arg3})
-	fake.recordInvocation("GetBundleForChannel", []interface{}{arg1, arg2, arg3})
-	fake.getBundleForChannelMutex.Unlock()
-	if fake.GetBundleForChannelStub != nil {
-		return fake.GetBundleForChannelStub(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.getBundleForChannelReturns
+	fakeReturns := fake.getBundleInPackageChannelReturns
 	return fakeReturns.result1, fakeReturns.result2
 }
 
-func (fake *FakeRegistryClient) GetBundleForChannelCallCount() int {
-	fake.getBundleForChannelMutex.RLock()
-	defer fake.getBundleForChannelMutex.RUnlock()
-	return len(fake.getBundleForChannelArgsForCall)
+func (fake *FakeInterface) GetBundleInPackageChannelCallCount() int {
+	fake.getBundleInPackageChannelMutex.RLock()
+	defer fake.getBundleInPackageChannelMutex.RUnlock()
+	return len(fake.getBundleInPackageChannelArgsForCall)
 }
 
-func (fake *FakeRegistryClient) GetBundleForChannelCalls(stub func(context.Context, *api.GetBundleInChannelRequest, ...grpc.CallOption) (*api.Bundle, error)) {
-	fake.getBundleForChannelMutex.Lock()
-	defer fake.getBundleForChannelMutex.Unlock()
-	fake.GetBundleForChannelStub = stub
+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 *FakeRegistryClient) GetBundleForChannelArgsForCall(i int) (context.Context, *api.GetBundleInChannelRequest, []grpc.CallOption) {
-	fake.getBundleForChannelMutex.RLock()
-	defer fake.getBundleForChannelMutex.RUnlock()
-	argsForCall := fake.getBundleForChannelArgsForCall[i]
+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 *FakeRegistryClient) GetBundleForChannelReturns(result1 *api.Bundle, result2 error) {
-	fake.getBundleForChannelMutex.Lock()
-	defer fake.getBundleForChannelMutex.Unlock()
-	fake.GetBundleForChannelStub = nil
-	fake.getBundleForChannelReturns = struct {
+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 *FakeRegistryClient) GetBundleForChannelReturnsOnCall(i int, result1 *api.Bundle, result2 error) {
-	fake.getBundleForChannelMutex.Lock()
-	defer fake.getBundleForChannelMutex.Unlock()
-	fake.GetBundleForChannelStub = nil
-	if fake.getBundleForChannelReturnsOnCall == nil {
-		fake.getBundleForChannelReturnsOnCall = make(map[int]struct {
+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.getBundleForChannelReturnsOnCall[i] = struct {
+	fake.getBundleInPackageChannelReturnsOnCall[i] = struct {
 		result1 *api.Bundle
 		result2 error
 	}{result1, result2}
 }
 
-func (fake *FakeRegistryClient) GetBundleThatReplaces(arg1 context.Context, arg2 *api.GetReplacementRequest, arg3 ...grpc.CallOption) (*api.Bundle, error) {
-	fake.getBundleThatReplacesMutex.Lock()
-	ret, specificReturn := fake.getBundleThatReplacesReturnsOnCall[len(fake.getBundleThatReplacesArgsForCall)]
-	fake.getBundleThatReplacesArgsForCall = append(fake.getBundleThatReplacesArgsForCall, struct {
+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 *api.GetReplacementRequest
-		arg3 []grpc.CallOption
-	}{arg1, arg2, arg3})
-	fake.recordInvocation("GetBundleThatReplaces", []interface{}{arg1, arg2, arg3})
-	fake.getBundleThatReplacesMutex.Unlock()
-	if fake.GetBundleThatReplacesStub != nil {
-		return fake.GetBundleThatReplacesStub(arg1, arg2, arg3...)
+		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.getBundleThatReplacesReturns
+	fakeReturns := fake.getBundleThatProvidesReturns
 	return fakeReturns.result1, fakeReturns.result2
 }
 
-func (fake *FakeRegistryClient) GetBundleThatReplacesCallCount() int {
-	fake.getBundleThatReplacesMutex.RLock()
-	defer fake.getBundleThatReplacesMutex.RUnlock()
-	return len(fake.getBundleThatReplacesArgsForCall)
+func (fake *FakeInterface) GetBundleThatProvidesCallCount() int {
+	fake.getBundleThatProvidesMutex.RLock()
+	defer fake.getBundleThatProvidesMutex.RUnlock()
+	return len(fake.getBundleThatProvidesArgsForCall)
 }
 
-func (fake *FakeRegistryClient) GetBundleThatReplacesCalls(stub func(context.Context, *api.GetReplacementRequest, ...grpc.CallOption) (*api.Bundle, error)) {
-	fake.getBundleThatReplacesMutex.Lock()
-	defer fake.getBundleThatReplacesMutex.Unlock()
-	fake.GetBundleThatReplacesStub = stub
+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 *FakeRegistryClient) GetBundleThatReplacesArgsForCall(i int) (context.Context, *api.GetReplacementRequest, []grpc.CallOption) {
-	fake.getBundleThatReplacesMutex.RLock()
-	defer fake.getBundleThatReplacesMutex.RUnlock()
-	argsForCall := fake.getBundleThatReplacesArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+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 *FakeRegistryClient) GetBundleThatReplacesReturns(result1 *api.Bundle, result2 error) {
-	fake.getBundleThatReplacesMutex.Lock()
-	defer fake.getBundleThatReplacesMutex.Unlock()
-	fake.GetBundleThatReplacesStub = nil
-	fake.getBundleThatReplacesReturns = struct {
+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 *FakeRegistryClient) GetBundleThatReplacesReturnsOnCall(i int, result1 *api.Bundle, result2 error) {
-	fake.getBundleThatReplacesMutex.Lock()
-	defer fake.getBundleThatReplacesMutex.Unlock()
-	fake.GetBundleThatReplacesStub = nil
-	if fake.getBundleThatReplacesReturnsOnCall == nil {
-		fake.getBundleThatReplacesReturnsOnCall = make(map[int]struct {
+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.getBundleThatReplacesReturnsOnCall[i] = struct {
+	fake.getBundleThatProvidesReturnsOnCall[i] = struct {
 		result1 *api.Bundle
 		result2 error
 	}{result1, result2}
 }
 
-func (fake *FakeRegistryClient) GetChannelEntriesThatProvide(arg1 context.Context, arg2 *api.GetAllProvidersRequest, arg3 ...grpc.CallOption) (api.Registry_GetChannelEntriesThatProvideClient, error) {
-	fake.getChannelEntriesThatProvideMutex.Lock()
-	ret, specificReturn := fake.getChannelEntriesThatProvideReturnsOnCall[len(fake.getChannelEntriesThatProvideArgsForCall)]
-	fake.getChannelEntriesThatProvideArgsForCall = append(fake.getChannelEntriesThatProvideArgsForCall, struct {
-		arg1 context.Context
-		arg2 *api.GetAllProvidersRequest
-		arg3 []grpc.CallOption
-	}{arg1, arg2, arg3})
-	fake.recordInvocation("GetChannelEntriesThatProvide", []interface{}{arg1, arg2, arg3})
-	fake.getChannelEntriesThatProvideMutex.Unlock()
-	if fake.GetChannelEntriesThatProvideStub != nil {
-		return fake.GetChannelEntriesThatProvideStub(arg1, arg2, arg3...)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.getChannelEntriesThatProvideReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeRegistryClient) GetChannelEntriesThatProvideCallCount() int {
-	fake.getChannelEntriesThatProvideMutex.RLock()
-	defer fake.getChannelEntriesThatProvideMutex.RUnlock()
-	return len(fake.getChannelEntriesThatProvideArgsForCall)
-}
-
-func (fake *FakeRegistryClient) GetChannelEntriesThatProvideCalls(stub func(context.Context, *api.GetAllProvidersRequest, ...grpc.CallOption) (api.Registry_GetChannelEntriesThatProvideClient, error)) {
-	fake.getChannelEntriesThatProvideMutex.Lock()
-	defer fake.getChannelEntriesThatProvideMutex.Unlock()
-	fake.GetChannelEntriesThatProvideStub = stub
-}
-
-func (fake *FakeRegistryClient) GetChannelEntriesThatProvideArgsForCall(i int) (context.Context, *api.GetAllProvidersRequest, []grpc.CallOption) {
-	fake.getChannelEntriesThatProvideMutex.RLock()
-	defer fake.getChannelEntriesThatProvideMutex.RUnlock()
-	argsForCall := fake.getChannelEntriesThatProvideArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *FakeRegistryClient) GetChannelEntriesThatProvideReturns(result1 api.Registry_GetChannelEntriesThatProvideClient, result2 error) {
-	fake.getChannelEntriesThatProvideMutex.Lock()
-	defer fake.getChannelEntriesThatProvideMutex.Unlock()
-	fake.GetChannelEntriesThatProvideStub = nil
-	fake.getChannelEntriesThatProvideReturns = struct {
-		result1 api.Registry_GetChannelEntriesThatProvideClient
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeRegistryClient) GetChannelEntriesThatProvideReturnsOnCall(i int, result1 api.Registry_GetChannelEntriesThatProvideClient, result2 error) {
-	fake.getChannelEntriesThatProvideMutex.Lock()
-	defer fake.getChannelEntriesThatProvideMutex.Unlock()
-	fake.GetChannelEntriesThatProvideStub = nil
-	if fake.getChannelEntriesThatProvideReturnsOnCall == nil {
-		fake.getChannelEntriesThatProvideReturnsOnCall = make(map[int]struct {
-			result1 api.Registry_GetChannelEntriesThatProvideClient
-			result2 error
-		})
-	}
-	fake.getChannelEntriesThatProvideReturnsOnCall[i] = struct {
-		result1 api.Registry_GetChannelEntriesThatProvideClient
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeRegistryClient) GetChannelEntriesThatReplace(arg1 context.Context, arg2 *api.GetAllReplacementsRequest, arg3 ...grpc.CallOption) (api.Registry_GetChannelEntriesThatReplaceClient, error) {
-	fake.getChannelEntriesThatReplaceMutex.Lock()
-	ret, specificReturn := fake.getChannelEntriesThatReplaceReturnsOnCall[len(fake.getChannelEntriesThatReplaceArgsForCall)]
-	fake.getChannelEntriesThatReplaceArgsForCall = append(fake.getChannelEntriesThatReplaceArgsForCall, struct {
-		arg1 context.Context
-		arg2 *api.GetAllReplacementsRequest
-		arg3 []grpc.CallOption
-	}{arg1, arg2, arg3})
-	fake.recordInvocation("GetChannelEntriesThatReplace", []interface{}{arg1, arg2, arg3})
-	fake.getChannelEntriesThatReplaceMutex.Unlock()
-	if fake.GetChannelEntriesThatReplaceStub != nil {
-		return fake.GetChannelEntriesThatReplaceStub(arg1, arg2, arg3...)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.getChannelEntriesThatReplaceReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeRegistryClient) GetChannelEntriesThatReplaceCallCount() int {
-	fake.getChannelEntriesThatReplaceMutex.RLock()
-	defer fake.getChannelEntriesThatReplaceMutex.RUnlock()
-	return len(fake.getChannelEntriesThatReplaceArgsForCall)
-}
-
-func (fake *FakeRegistryClient) GetChannelEntriesThatReplaceCalls(stub func(context.Context, *api.GetAllReplacementsRequest, ...grpc.CallOption) (api.Registry_GetChannelEntriesThatReplaceClient, error)) {
-	fake.getChannelEntriesThatReplaceMutex.Lock()
-	defer fake.getChannelEntriesThatReplaceMutex.Unlock()
-	fake.GetChannelEntriesThatReplaceStub = stub
-}
-
-func (fake *FakeRegistryClient) GetChannelEntriesThatReplaceArgsForCall(i int) (context.Context, *api.GetAllReplacementsRequest, []grpc.CallOption) {
-	fake.getChannelEntriesThatReplaceMutex.RLock()
-	defer fake.getChannelEntriesThatReplaceMutex.RUnlock()
-	argsForCall := fake.getChannelEntriesThatReplaceArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *FakeRegistryClient) GetChannelEntriesThatReplaceReturns(result1 api.Registry_GetChannelEntriesThatReplaceClient, result2 error) {
-	fake.getChannelEntriesThatReplaceMutex.Lock()
-	defer fake.getChannelEntriesThatReplaceMutex.Unlock()
-	fake.GetChannelEntriesThatReplaceStub = nil
-	fake.getChannelEntriesThatReplaceReturns = struct {
-		result1 api.Registry_GetChannelEntriesThatReplaceClient
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeRegistryClient) GetChannelEntriesThatReplaceReturnsOnCall(i int, result1 api.Registry_GetChannelEntriesThatReplaceClient, result2 error) {
-	fake.getChannelEntriesThatReplaceMutex.Lock()
-	defer fake.getChannelEntriesThatReplaceMutex.Unlock()
-	fake.GetChannelEntriesThatReplaceStub = nil
-	if fake.getChannelEntriesThatReplaceReturnsOnCall == nil {
-		fake.getChannelEntriesThatReplaceReturnsOnCall = make(map[int]struct {
-			result1 api.Registry_GetChannelEntriesThatReplaceClient
-			result2 error
-		})
-	}
-	fake.getChannelEntriesThatReplaceReturnsOnCall[i] = struct {
-		result1 api.Registry_GetChannelEntriesThatReplaceClient
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeRegistryClient) GetDefaultBundleThatProvides(arg1 context.Context, arg2 *api.GetDefaultProviderRequest, arg3 ...grpc.CallOption) (*api.Bundle, error) {
-	fake.getDefaultBundleThatProvidesMutex.Lock()
-	ret, specificReturn := fake.getDefaultBundleThatProvidesReturnsOnCall[len(fake.getDefaultBundleThatProvidesArgsForCall)]
-	fake.getDefaultBundleThatProvidesArgsForCall = append(fake.getDefaultBundleThatProvidesArgsForCall, struct {
+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 *api.GetDefaultProviderRequest
-		arg3 []grpc.CallOption
-	}{arg1, arg2, arg3})
-	fake.recordInvocation("GetDefaultBundleThatProvides", []interface{}{arg1, arg2, arg3})
-	fake.getDefaultBundleThatProvidesMutex.Unlock()
-	if fake.GetDefaultBundleThatProvidesStub != nil {
-		return fake.GetDefaultBundleThatProvidesStub(arg1, arg2, arg3...)
+		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.getDefaultBundleThatProvidesReturns
+	fakeReturns := fake.getReplacementBundleInPackageChannelReturns
 	return fakeReturns.result1, fakeReturns.result2
 }
 
-func (fake *FakeRegistryClient) GetDefaultBundleThatProvidesCallCount() int {
-	fake.getDefaultBundleThatProvidesMutex.RLock()
-	defer fake.getDefaultBundleThatProvidesMutex.RUnlock()
-	return len(fake.getDefaultBundleThatProvidesArgsForCall)
+func (fake *FakeInterface) GetReplacementBundleInPackageChannelCallCount() int {
+	fake.getReplacementBundleInPackageChannelMutex.RLock()
+	defer fake.getReplacementBundleInPackageChannelMutex.RUnlock()
+	return len(fake.getReplacementBundleInPackageChannelArgsForCall)
 }
 
-func (fake *FakeRegistryClient) GetDefaultBundleThatProvidesCalls(stub func(context.Context, *api.GetDefaultProviderRequest, ...grpc.CallOption) (*api.Bundle, error)) {
-	fake.getDefaultBundleThatProvidesMutex.Lock()
-	defer fake.getDefaultBundleThatProvidesMutex.Unlock()
-	fake.GetDefaultBundleThatProvidesStub = stub
+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 *FakeRegistryClient) GetDefaultBundleThatProvidesArgsForCall(i int) (context.Context, *api.GetDefaultProviderRequest, []grpc.CallOption) {
-	fake.getDefaultBundleThatProvidesMutex.RLock()
-	defer fake.getDefaultBundleThatProvidesMutex.RUnlock()
-	argsForCall := fake.getDefaultBundleThatProvidesArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+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 *FakeRegistryClient) GetDefaultBundleThatProvidesReturns(result1 *api.Bundle, result2 error) {
-	fake.getDefaultBundleThatProvidesMutex.Lock()
-	defer fake.getDefaultBundleThatProvidesMutex.Unlock()
-	fake.GetDefaultBundleThatProvidesStub = nil
-	fake.getDefaultBundleThatProvidesReturns = struct {
+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 *FakeRegistryClient) GetDefaultBundleThatProvidesReturnsOnCall(i int, result1 *api.Bundle, result2 error) {
-	fake.getDefaultBundleThatProvidesMutex.Lock()
-	defer fake.getDefaultBundleThatProvidesMutex.Unlock()
-	fake.GetDefaultBundleThatProvidesStub = nil
-	if fake.getDefaultBundleThatProvidesReturnsOnCall == nil {
-		fake.getDefaultBundleThatProvidesReturnsOnCall = make(map[int]struct {
+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.getDefaultBundleThatProvidesReturnsOnCall[i] = struct {
+	fake.getReplacementBundleInPackageChannelReturnsOnCall[i] = struct {
 		result1 *api.Bundle
 		result2 error
 	}{result1, result2}
 }
 
-func (fake *FakeRegistryClient) GetLatestChannelEntriesThatProvide(arg1 context.Context, arg2 *api.GetLatestProvidersRequest, arg3 ...grpc.CallOption) (api.Registry_GetLatestChannelEntriesThatProvideClient, error) {
-	fake.getLatestChannelEntriesThatProvideMutex.Lock()
-	ret, specificReturn := fake.getLatestChannelEntriesThatProvideReturnsOnCall[len(fake.getLatestChannelEntriesThatProvideArgsForCall)]
-	fake.getLatestChannelEntriesThatProvideArgsForCall = append(fake.getLatestChannelEntriesThatProvideArgsForCall, struct {
+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 *api.GetLatestProvidersRequest
-		arg3 []grpc.CallOption
-	}{arg1, arg2, arg3})
-	fake.recordInvocation("GetLatestChannelEntriesThatProvide", []interface{}{arg1, arg2, arg3})
-	fake.getLatestChannelEntriesThatProvideMutex.Unlock()
-	if fake.GetLatestChannelEntriesThatProvideStub != nil {
-		return fake.GetLatestChannelEntriesThatProvideStub(arg1, arg2, arg3...)
+		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.getLatestChannelEntriesThatProvideReturns
+	fakeReturns := fake.healthCheckReturns
 	return fakeReturns.result1, fakeReturns.result2
 }
 
-func (fake *FakeRegistryClient) GetLatestChannelEntriesThatProvideCallCount() int {
-	fake.getLatestChannelEntriesThatProvideMutex.RLock()
-	defer fake.getLatestChannelEntriesThatProvideMutex.RUnlock()
-	return len(fake.getLatestChannelEntriesThatProvideArgsForCall)
+func (fake *FakeInterface) HealthCheckCallCount() int {
+	fake.healthCheckMutex.RLock()
+	defer fake.healthCheckMutex.RUnlock()
+	return len(fake.healthCheckArgsForCall)
 }
 
-func (fake *FakeRegistryClient) GetLatestChannelEntriesThatProvideCalls(stub func(context.Context, *api.GetLatestProvidersRequest, ...grpc.CallOption) (api.Registry_GetLatestChannelEntriesThatProvideClient, error)) {
-	fake.getLatestChannelEntriesThatProvideMutex.Lock()
-	defer fake.getLatestChannelEntriesThatProvideMutex.Unlock()
-	fake.GetLatestChannelEntriesThatProvideStub = stub
+func (fake *FakeInterface) HealthCheckCalls(stub func(context.Context, time.Duration) (bool, error)) {
+	fake.healthCheckMutex.Lock()
+	defer fake.healthCheckMutex.Unlock()
+	fake.HealthCheckStub = stub
 }
 
-func (fake *FakeRegistryClient) GetLatestChannelEntriesThatProvideArgsForCall(i int) (context.Context, *api.GetLatestProvidersRequest, []grpc.CallOption) {
-	fake.getLatestChannelEntriesThatProvideMutex.RLock()
-	defer fake.getLatestChannelEntriesThatProvideMutex.RUnlock()
-	argsForCall := fake.getLatestChannelEntriesThatProvideArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+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 *FakeRegistryClient) GetLatestChannelEntriesThatProvideReturns(result1 api.Registry_GetLatestChannelEntriesThatProvideClient, result2 error) {
-	fake.getLatestChannelEntriesThatProvideMutex.Lock()
-	defer fake.getLatestChannelEntriesThatProvideMutex.Unlock()
-	fake.GetLatestChannelEntriesThatProvideStub = nil
-	fake.getLatestChannelEntriesThatProvideReturns = struct {
-		result1 api.Registry_GetLatestChannelEntriesThatProvideClient
+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 *FakeRegistryClient) GetLatestChannelEntriesThatProvideReturnsOnCall(i int, result1 api.Registry_GetLatestChannelEntriesThatProvideClient, result2 error) {
-	fake.getLatestChannelEntriesThatProvideMutex.Lock()
-	defer fake.getLatestChannelEntriesThatProvideMutex.Unlock()
-	fake.GetLatestChannelEntriesThatProvideStub = nil
-	if fake.getLatestChannelEntriesThatProvideReturnsOnCall == nil {
-		fake.getLatestChannelEntriesThatProvideReturnsOnCall = make(map[int]struct {
-			result1 api.Registry_GetLatestChannelEntriesThatProvideClient
+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.getLatestChannelEntriesThatProvideReturnsOnCall[i] = struct {
-		result1 api.Registry_GetLatestChannelEntriesThatProvideClient
+	fake.healthCheckReturnsOnCall[i] = struct {
+		result1 bool
 		result2 error
 	}{result1, result2}
 }
 
-func (fake *FakeRegistryClient) GetPackage(arg1 context.Context, arg2 *api.GetPackageRequest, arg3 ...grpc.CallOption) (*api.Package, error) {
-	fake.getPackageMutex.Lock()
-	ret, specificReturn := fake.getPackageReturnsOnCall[len(fake.getPackageArgsForCall)]
-	fake.getPackageArgsForCall = append(fake.getPackageArgsForCall, struct {
-		arg1 context.Context
-		arg2 *api.GetPackageRequest
-		arg3 []grpc.CallOption
-	}{arg1, arg2, arg3})
-	fake.recordInvocation("GetPackage", []interface{}{arg1, arg2, arg3})
-	fake.getPackageMutex.Unlock()
-	if fake.GetPackageStub != nil {
-		return fake.GetPackageStub(arg1, arg2, arg3...)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.getPackageReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeRegistryClient) GetPackageCallCount() int {
-	fake.getPackageMutex.RLock()
-	defer fake.getPackageMutex.RUnlock()
-	return len(fake.getPackageArgsForCall)
-}
-
-func (fake *FakeRegistryClient) GetPackageCalls(stub func(context.Context, *api.GetPackageRequest, ...grpc.CallOption) (*api.Package, error)) {
-	fake.getPackageMutex.Lock()
-	defer fake.getPackageMutex.Unlock()
-	fake.GetPackageStub = stub
-}
-
-func (fake *FakeRegistryClient) GetPackageArgsForCall(i int) (context.Context, *api.GetPackageRequest, []grpc.CallOption) {
-	fake.getPackageMutex.RLock()
-	defer fake.getPackageMutex.RUnlock()
-	argsForCall := fake.getPackageArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *FakeRegistryClient) 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 *FakeRegistryClient) 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 *FakeRegistryClient) ListBundles(arg1 context.Context, arg2 *api.ListBundlesRequest, arg3 ...grpc.CallOption) (api.Registry_ListBundlesClient, error) {
+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
-		arg2 *api.ListBundlesRequest
-		arg3 []grpc.CallOption
-	}{arg1, arg2, arg3})
-	fake.recordInvocation("ListBundles", []interface{}{arg1, arg2, arg3})
+	}{arg1})
+	fake.recordInvocation("ListBundles", []interface{}{arg1})
 	fake.listBundlesMutex.Unlock()
 	if fake.ListBundlesStub != nil {
-		return fake.ListBundlesStub(arg1, arg2, arg3...)
+		return fake.ListBundlesStub(arg1)
 	}
 	if specificReturn {
 		return ret.result1, ret.result2
@@ -704,139 +512,68 @@ func (fake *FakeRegistryClient) ListBundles(arg1 context.Context, arg2 *api.List
 	return fakeReturns.result1, fakeReturns.result2
 }
 
-func (fake *FakeRegistryClient) ListBundlesCallCount() int {
+func (fake *FakeInterface) ListBundlesCallCount() int {
 	fake.listBundlesMutex.RLock()
 	defer fake.listBundlesMutex.RUnlock()
 	return len(fake.listBundlesArgsForCall)
 }
 
-func (fake *FakeRegistryClient) ListBundlesCalls(stub func(context.Context, *api.ListBundlesRequest, ...grpc.CallOption) (api.Registry_ListBundlesClient, error)) {
+func (fake *FakeInterface) ListBundlesCalls(stub func(context.Context) (*client.BundleIterator, error)) {
 	fake.listBundlesMutex.Lock()
 	defer fake.listBundlesMutex.Unlock()
 	fake.ListBundlesStub = stub
 }
 
-func (fake *FakeRegistryClient) ListBundlesArgsForCall(i int) (context.Context, *api.ListBundlesRequest, []grpc.CallOption) {
+func (fake *FakeInterface) ListBundlesArgsForCall(i int) context.Context {
 	fake.listBundlesMutex.RLock()
 	defer fake.listBundlesMutex.RUnlock()
 	argsForCall := fake.listBundlesArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+	return argsForCall.arg1
 }
 
-func (fake *FakeRegistryClient) ListBundlesReturns(result1 api.Registry_ListBundlesClient, result2 error) {
+func (fake *FakeInterface) ListBundlesReturns(result1 *client.BundleIterator, result2 error) {
 	fake.listBundlesMutex.Lock()
 	defer fake.listBundlesMutex.Unlock()
 	fake.ListBundlesStub = nil
 	fake.listBundlesReturns = struct {
-		result1 api.Registry_ListBundlesClient
+		result1 *client.BundleIterator
 		result2 error
 	}{result1, result2}
 }
 
-func (fake *FakeRegistryClient) ListBundlesReturnsOnCall(i int, result1 api.Registry_ListBundlesClient, result2 error) {
+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 api.Registry_ListBundlesClient
+			result1 *client.BundleIterator
 			result2 error
 		})
 	}
 	fake.listBundlesReturnsOnCall[i] = struct {
-		result1 api.Registry_ListBundlesClient
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeRegistryClient) ListPackages(arg1 context.Context, arg2 *api.ListPackageRequest, arg3 ...grpc.CallOption) (api.Registry_ListPackagesClient, error) {
-	fake.listPackagesMutex.Lock()
-	ret, specificReturn := fake.listPackagesReturnsOnCall[len(fake.listPackagesArgsForCall)]
-	fake.listPackagesArgsForCall = append(fake.listPackagesArgsForCall, struct {
-		arg1 context.Context
-		arg2 *api.ListPackageRequest
-		arg3 []grpc.CallOption
-	}{arg1, arg2, arg3})
-	fake.recordInvocation("ListPackages", []interface{}{arg1, arg2, arg3})
-	fake.listPackagesMutex.Unlock()
-	if fake.ListPackagesStub != nil {
-		return fake.ListPackagesStub(arg1, arg2, arg3...)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.listPackagesReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeRegistryClient) ListPackagesCallCount() int {
-	fake.listPackagesMutex.RLock()
-	defer fake.listPackagesMutex.RUnlock()
-	return len(fake.listPackagesArgsForCall)
-}
-
-func (fake *FakeRegistryClient) ListPackagesCalls(stub func(context.Context, *api.ListPackageRequest, ...grpc.CallOption) (api.Registry_ListPackagesClient, error)) {
-	fake.listPackagesMutex.Lock()
-	defer fake.listPackagesMutex.Unlock()
-	fake.ListPackagesStub = stub
-}
-
-func (fake *FakeRegistryClient) ListPackagesArgsForCall(i int) (context.Context, *api.ListPackageRequest, []grpc.CallOption) {
-	fake.listPackagesMutex.RLock()
-	defer fake.listPackagesMutex.RUnlock()
-	argsForCall := fake.listPackagesArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *FakeRegistryClient) ListPackagesReturns(result1 api.Registry_ListPackagesClient, result2 error) {
-	fake.listPackagesMutex.Lock()
-	defer fake.listPackagesMutex.Unlock()
-	fake.ListPackagesStub = nil
-	fake.listPackagesReturns = struct {
-		result1 api.Registry_ListPackagesClient
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeRegistryClient) ListPackagesReturnsOnCall(i int, result1 api.Registry_ListPackagesClient, result2 error) {
-	fake.listPackagesMutex.Lock()
-	defer fake.listPackagesMutex.Unlock()
-	fake.ListPackagesStub = nil
-	if fake.listPackagesReturnsOnCall == nil {
-		fake.listPackagesReturnsOnCall = make(map[int]struct {
-			result1 api.Registry_ListPackagesClient
-			result2 error
-		})
-	}
-	fake.listPackagesReturnsOnCall[i] = struct {
-		result1 api.Registry_ListPackagesClient
+		result1 *client.BundleIterator
 		result2 error
 	}{result1, result2}
 }
 
-func (fake *FakeRegistryClient) Invocations() map[string][][]interface{} {
+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.getBundleForChannelMutex.RLock()
-	defer fake.getBundleForChannelMutex.RUnlock()
-	fake.getBundleThatReplacesMutex.RLock()
-	defer fake.getBundleThatReplacesMutex.RUnlock()
-	fake.getChannelEntriesThatProvideMutex.RLock()
-	defer fake.getChannelEntriesThatProvideMutex.RUnlock()
-	fake.getChannelEntriesThatReplaceMutex.RLock()
-	defer fake.getChannelEntriesThatReplaceMutex.RUnlock()
-	fake.getDefaultBundleThatProvidesMutex.RLock()
-	defer fake.getDefaultBundleThatProvidesMutex.RUnlock()
-	fake.getLatestChannelEntriesThatProvideMutex.RLock()
-	defer fake.getLatestChannelEntriesThatProvideMutex.RUnlock()
-	fake.getPackageMutex.RLock()
-	defer fake.getPackageMutex.RUnlock()
+	fake.getBundleInPackageChannelMutex.RLock()
+	defer fake.getBundleInPackageChannelMutex.RUnlock()
+	fake.getBundleThatProvidesMutex.RLock()
+	defer fake.getBundleThatProvidesMutex.RUnlock()
+	fake.getReplacementBundleInPackageChannelMutex.RLock()
+	defer fake.getReplacementBundleInPackageChannelMutex.RUnlock()
+	fake.healthCheckMutex.RLock()
+	defer fake.healthCheckMutex.RUnlock()
 	fake.listBundlesMutex.RLock()
 	defer fake.listBundlesMutex.RUnlock()
-	fake.listPackagesMutex.RLock()
-	defer fake.listPackagesMutex.RUnlock()
 	copiedInvocations := map[string][][]interface{}{}
 	for key, value := range fake.invocations {
 		copiedInvocations[key] = value
@@ -844,7 +581,7 @@ func (fake *FakeRegistryClient) Invocations() map[string][][]interface{} {
 	return copiedInvocations
 }
 
-func (fake *FakeRegistryClient) recordInvocation(key string, args []interface{}) {
+func (fake *FakeInterface) recordInvocation(key string, args []interface{}) {
 	fake.invocationsMutex.Lock()
 	defer fake.invocationsMutex.Unlock()
 	if fake.invocations == nil {
@@ -856,4 +593,4 @@ func (fake *FakeRegistryClient) recordInvocation(key string, args []interface{})
 	fake.invocations[key] = append(fake.invocations[key], args)
 }
 
-var _ api.RegistryClient = new(FakeRegistryClient)
+var _ client.Interface = new(FakeInterface)
diff --git a/pkg/controller/registry/resolver/fakes/fake_registry_client_interface.go b/pkg/controller/registry/resolver/fakes/fake_registry_client_interface.go
deleted file mode 100644
index 8f90ac342..000000000
--- a/pkg/controller/registry/resolver/fakes/fake_registry_client_interface.go
+++ /dev/null
@@ -1,767 +0,0 @@
-// Code generated by counterfeiter. DO NOT EDIT.
-package fakes
-
-import (
-	"context"
-	"sync"
-	"time"
-
-	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry"
-	"github.com/operator-framework/operator-registry/pkg/api"
-	"github.com/operator-framework/operator-registry/pkg/client"
-)
-
-type FakeClientInterface struct {
-	CloseStub        func() error
-	closeMutex       sync.RWMutex
-	closeArgsForCall []struct {
-	}
-	closeReturns struct {
-		result1 error
-	}
-	closeReturnsOnCall map[int]struct {
-		result1 error
-	}
-	FindBundleThatProvidesStub        func(context.Context, string, string, string, string) (*api.Bundle, error)
-	findBundleThatProvidesMutex       sync.RWMutex
-	findBundleThatProvidesArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 string
-		arg5 string
-	}
-	findBundleThatProvidesReturns struct {
-		result1 *api.Bundle
-		result2 error
-	}
-	findBundleThatProvidesReturnsOnCall map[int]struct {
-		result1 *api.Bundle
-		result2 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
-	}
-	GetLatestChannelEntriesThatProvideStub        func(context.Context, string, string, string) (*registry.ChannelEntryIterator, error)
-	getLatestChannelEntriesThatProvideMutex       sync.RWMutex
-	getLatestChannelEntriesThatProvideArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 string
-	}
-	getLatestChannelEntriesThatProvideReturns struct {
-		result1 *registry.ChannelEntryIterator
-		result2 error
-	}
-	getLatestChannelEntriesThatProvideReturnsOnCall map[int]struct {
-		result1 *registry.ChannelEntryIterator
-		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 *FakeClientInterface) 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 *FakeClientInterface) CloseCallCount() int {
-	fake.closeMutex.RLock()
-	defer fake.closeMutex.RUnlock()
-	return len(fake.closeArgsForCall)
-}
-
-func (fake *FakeClientInterface) CloseCalls(stub func() error) {
-	fake.closeMutex.Lock()
-	defer fake.closeMutex.Unlock()
-	fake.CloseStub = stub
-}
-
-func (fake *FakeClientInterface) CloseReturns(result1 error) {
-	fake.closeMutex.Lock()
-	defer fake.closeMutex.Unlock()
-	fake.CloseStub = nil
-	fake.closeReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeClientInterface) 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 *FakeClientInterface) FindBundleThatProvides(arg1 context.Context, arg2 string, arg3 string, arg4 string, arg5 string) (*api.Bundle, error) {
-	fake.findBundleThatProvidesMutex.Lock()
-	ret, specificReturn := fake.findBundleThatProvidesReturnsOnCall[len(fake.findBundleThatProvidesArgsForCall)]
-	fake.findBundleThatProvidesArgsForCall = append(fake.findBundleThatProvidesArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 string
-		arg5 string
-	}{arg1, arg2, arg3, arg4, arg5})
-	fake.recordInvocation("FindBundleThatProvides", []interface{}{arg1, arg2, arg3, arg4, arg5})
-	fake.findBundleThatProvidesMutex.Unlock()
-	if fake.FindBundleThatProvidesStub != nil {
-		return fake.FindBundleThatProvidesStub(arg1, arg2, arg3, arg4, arg5)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.findBundleThatProvidesReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeClientInterface) FindBundleThatProvidesCallCount() int {
-	fake.findBundleThatProvidesMutex.RLock()
-	defer fake.findBundleThatProvidesMutex.RUnlock()
-	return len(fake.findBundleThatProvidesArgsForCall)
-}
-
-func (fake *FakeClientInterface) FindBundleThatProvidesCalls(stub func(context.Context, string, string, string, string) (*api.Bundle, error)) {
-	fake.findBundleThatProvidesMutex.Lock()
-	defer fake.findBundleThatProvidesMutex.Unlock()
-	fake.FindBundleThatProvidesStub = stub
-}
-
-func (fake *FakeClientInterface) FindBundleThatProvidesArgsForCall(i int) (context.Context, string, string, string, string) {
-	fake.findBundleThatProvidesMutex.RLock()
-	defer fake.findBundleThatProvidesMutex.RUnlock()
-	argsForCall := fake.findBundleThatProvidesArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
-}
-
-func (fake *FakeClientInterface) FindBundleThatProvidesReturns(result1 *api.Bundle, result2 error) {
-	fake.findBundleThatProvidesMutex.Lock()
-	defer fake.findBundleThatProvidesMutex.Unlock()
-	fake.FindBundleThatProvidesStub = nil
-	fake.findBundleThatProvidesReturns = struct {
-		result1 *api.Bundle
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeClientInterface) FindBundleThatProvidesReturnsOnCall(i int, result1 *api.Bundle, result2 error) {
-	fake.findBundleThatProvidesMutex.Lock()
-	defer fake.findBundleThatProvidesMutex.Unlock()
-	fake.FindBundleThatProvidesStub = nil
-	if fake.findBundleThatProvidesReturnsOnCall == nil {
-		fake.findBundleThatProvidesReturnsOnCall = make(map[int]struct {
-			result1 *api.Bundle
-			result2 error
-		})
-	}
-	fake.findBundleThatProvidesReturnsOnCall[i] = struct {
-		result1 *api.Bundle
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeClientInterface) 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 *FakeClientInterface) GetBundleCallCount() int {
-	fake.getBundleMutex.RLock()
-	defer fake.getBundleMutex.RUnlock()
-	return len(fake.getBundleArgsForCall)
-}
-
-func (fake *FakeClientInterface) GetBundleCalls(stub func(context.Context, string, string, string) (*api.Bundle, error)) {
-	fake.getBundleMutex.Lock()
-	defer fake.getBundleMutex.Unlock()
-	fake.GetBundleStub = stub
-}
-
-func (fake *FakeClientInterface) 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 *FakeClientInterface) 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 *FakeClientInterface) 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 *FakeClientInterface) 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 *FakeClientInterface) GetBundleInPackageChannelCallCount() int {
-	fake.getBundleInPackageChannelMutex.RLock()
-	defer fake.getBundleInPackageChannelMutex.RUnlock()
-	return len(fake.getBundleInPackageChannelArgsForCall)
-}
-
-func (fake *FakeClientInterface) GetBundleInPackageChannelCalls(stub func(context.Context, string, string) (*api.Bundle, error)) {
-	fake.getBundleInPackageChannelMutex.Lock()
-	defer fake.getBundleInPackageChannelMutex.Unlock()
-	fake.GetBundleInPackageChannelStub = stub
-}
-
-func (fake *FakeClientInterface) 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 *FakeClientInterface) 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 *FakeClientInterface) 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 *FakeClientInterface) 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 *FakeClientInterface) GetBundleThatProvidesCallCount() int {
-	fake.getBundleThatProvidesMutex.RLock()
-	defer fake.getBundleThatProvidesMutex.RUnlock()
-	return len(fake.getBundleThatProvidesArgsForCall)
-}
-
-func (fake *FakeClientInterface) GetBundleThatProvidesCalls(stub func(context.Context, string, string, string) (*api.Bundle, error)) {
-	fake.getBundleThatProvidesMutex.Lock()
-	defer fake.getBundleThatProvidesMutex.Unlock()
-	fake.GetBundleThatProvidesStub = stub
-}
-
-func (fake *FakeClientInterface) 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 *FakeClientInterface) 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 *FakeClientInterface) 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 *FakeClientInterface) GetLatestChannelEntriesThatProvide(arg1 context.Context, arg2 string, arg3 string, arg4 string) (*registry.ChannelEntryIterator, error) {
-	fake.getLatestChannelEntriesThatProvideMutex.Lock()
-	ret, specificReturn := fake.getLatestChannelEntriesThatProvideReturnsOnCall[len(fake.getLatestChannelEntriesThatProvideArgsForCall)]
-	fake.getLatestChannelEntriesThatProvideArgsForCall = append(fake.getLatestChannelEntriesThatProvideArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 string
-	}{arg1, arg2, arg3, arg4})
-	fake.recordInvocation("GetLatestChannelEntriesThatProvide", []interface{}{arg1, arg2, arg3, arg4})
-	fake.getLatestChannelEntriesThatProvideMutex.Unlock()
-	if fake.GetLatestChannelEntriesThatProvideStub != nil {
-		return fake.GetLatestChannelEntriesThatProvideStub(arg1, arg2, arg3, arg4)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.getLatestChannelEntriesThatProvideReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeClientInterface) GetLatestChannelEntriesThatProvideCallCount() int {
-	fake.getLatestChannelEntriesThatProvideMutex.RLock()
-	defer fake.getLatestChannelEntriesThatProvideMutex.RUnlock()
-	return len(fake.getLatestChannelEntriesThatProvideArgsForCall)
-}
-
-func (fake *FakeClientInterface) GetLatestChannelEntriesThatProvideCalls(stub func(context.Context, string, string, string) (*registry.ChannelEntryIterator, error)) {
-	fake.getLatestChannelEntriesThatProvideMutex.Lock()
-	defer fake.getLatestChannelEntriesThatProvideMutex.Unlock()
-	fake.GetLatestChannelEntriesThatProvideStub = stub
-}
-
-func (fake *FakeClientInterface) GetLatestChannelEntriesThatProvideArgsForCall(i int) (context.Context, string, string, string) {
-	fake.getLatestChannelEntriesThatProvideMutex.RLock()
-	defer fake.getLatestChannelEntriesThatProvideMutex.RUnlock()
-	argsForCall := fake.getLatestChannelEntriesThatProvideArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
-}
-
-func (fake *FakeClientInterface) GetLatestChannelEntriesThatProvideReturns(result1 *registry.ChannelEntryIterator, result2 error) {
-	fake.getLatestChannelEntriesThatProvideMutex.Lock()
-	defer fake.getLatestChannelEntriesThatProvideMutex.Unlock()
-	fake.GetLatestChannelEntriesThatProvideStub = nil
-	fake.getLatestChannelEntriesThatProvideReturns = struct {
-		result1 *registry.ChannelEntryIterator
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeClientInterface) GetLatestChannelEntriesThatProvideReturnsOnCall(i int, result1 *registry.ChannelEntryIterator, result2 error) {
-	fake.getLatestChannelEntriesThatProvideMutex.Lock()
-	defer fake.getLatestChannelEntriesThatProvideMutex.Unlock()
-	fake.GetLatestChannelEntriesThatProvideStub = nil
-	if fake.getLatestChannelEntriesThatProvideReturnsOnCall == nil {
-		fake.getLatestChannelEntriesThatProvideReturnsOnCall = make(map[int]struct {
-			result1 *registry.ChannelEntryIterator
-			result2 error
-		})
-	}
-	fake.getLatestChannelEntriesThatProvideReturnsOnCall[i] = struct {
-		result1 *registry.ChannelEntryIterator
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeClientInterface) 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 *FakeClientInterface) GetReplacementBundleInPackageChannelCallCount() int {
-	fake.getReplacementBundleInPackageChannelMutex.RLock()
-	defer fake.getReplacementBundleInPackageChannelMutex.RUnlock()
-	return len(fake.getReplacementBundleInPackageChannelArgsForCall)
-}
-
-func (fake *FakeClientInterface) GetReplacementBundleInPackageChannelCalls(stub func(context.Context, string, string, string) (*api.Bundle, error)) {
-	fake.getReplacementBundleInPackageChannelMutex.Lock()
-	defer fake.getReplacementBundleInPackageChannelMutex.Unlock()
-	fake.GetReplacementBundleInPackageChannelStub = stub
-}
-
-func (fake *FakeClientInterface) 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 *FakeClientInterface) 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 *FakeClientInterface) 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 *FakeClientInterface) 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 *FakeClientInterface) HealthCheckCallCount() int {
-	fake.healthCheckMutex.RLock()
-	defer fake.healthCheckMutex.RUnlock()
-	return len(fake.healthCheckArgsForCall)
-}
-
-func (fake *FakeClientInterface) HealthCheckCalls(stub func(context.Context, time.Duration) (bool, error)) {
-	fake.healthCheckMutex.Lock()
-	defer fake.healthCheckMutex.Unlock()
-	fake.HealthCheckStub = stub
-}
-
-func (fake *FakeClientInterface) 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 *FakeClientInterface) 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 *FakeClientInterface) 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 *FakeClientInterface) 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 *FakeClientInterface) ListBundlesCallCount() int {
-	fake.listBundlesMutex.RLock()
-	defer fake.listBundlesMutex.RUnlock()
-	return len(fake.listBundlesArgsForCall)
-}
-
-func (fake *FakeClientInterface) ListBundlesCalls(stub func(context.Context) (*client.BundleIterator, error)) {
-	fake.listBundlesMutex.Lock()
-	defer fake.listBundlesMutex.Unlock()
-	fake.ListBundlesStub = stub
-}
-
-func (fake *FakeClientInterface) ListBundlesArgsForCall(i int) context.Context {
-	fake.listBundlesMutex.RLock()
-	defer fake.listBundlesMutex.RUnlock()
-	argsForCall := fake.listBundlesArgsForCall[i]
-	return argsForCall.arg1
-}
-
-func (fake *FakeClientInterface) 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 *FakeClientInterface) 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 *FakeClientInterface) Invocations() map[string][][]interface{} {
-	fake.invocationsMutex.RLock()
-	defer fake.invocationsMutex.RUnlock()
-	fake.closeMutex.RLock()
-	defer fake.closeMutex.RUnlock()
-	fake.findBundleThatProvidesMutex.RLock()
-	defer fake.findBundleThatProvidesMutex.RUnlock()
-	fake.getBundleMutex.RLock()
-	defer fake.getBundleMutex.RUnlock()
-	fake.getBundleInPackageChannelMutex.RLock()
-	defer fake.getBundleInPackageChannelMutex.RUnlock()
-	fake.getBundleThatProvidesMutex.RLock()
-	defer fake.getBundleThatProvidesMutex.RUnlock()
-	fake.getLatestChannelEntriesThatProvideMutex.RLock()
-	defer fake.getLatestChannelEntriesThatProvideMutex.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 *FakeClientInterface) 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 _ registry.ClientInterface = new(FakeClientInterface)
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 1afca0637..000000000
--- a/pkg/controller/registry/resolver/fakes/fake_registry_interface.go
+++ /dev/null
@@ -1,596 +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
-	}
-	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) 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.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/querier.go b/pkg/controller/registry/resolver/querier.go
index 89ba9308f..f6d0b055e 100644
--- a/pkg/controller/registry/resolver/querier.go
+++ b/pkg/controller/registry/resolver/querier.go
@@ -1,5 +1,4 @@
-//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
+//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -o fakes/fake_registry_client.go ../../../../vendor/github.com/operator-framework/operator-registry/pkg/client/client.go Interface
 package resolver
 
 import (
@@ -11,11 +10,8 @@ import (
 	"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"
@@ -28,7 +24,7 @@ type SourceRef struct {
 }
 
 type SourceQuerier interface {
-	FindProvider(api opregistry.APIKey, initialSource CatalogKey, excludedPkgName string) (*api.Bundle, *CatalogKey, error)
+	FindProvider(api opregistry.APIKey, initialSource CatalogKey) (*api.Bundle, *CatalogKey, error)
 	FindBundle(pkgName, channelName, bundleName string, initialSource CatalogKey) (*api.Bundle, *CatalogKey, error)
 	FindLatestBundle(pkgName, channelName string, initialSource CatalogKey) (*api.Bundle, *CatalogKey, error)
 	FindReplacement(currentVersion *semver.Version, bundleName, pkgName, channelName string, initialSource CatalogKey) (*api.Bundle, *CatalogKey, error)
@@ -36,12 +32,12 @@ type SourceQuerier interface {
 }
 
 type NamespaceSourceQuerier struct {
-	sources map[CatalogKey]registry.ClientInterface
+	sources map[CatalogKey]client.Interface
 }
 
 var _ SourceQuerier = &NamespaceSourceQuerier{}
 
-func NewNamespaceSourceQuerier(sources map[CatalogKey]registry.ClientInterface) *NamespaceSourceQuerier {
+func NewNamespaceSourceQuerier(sources map[CatalogKey]client.Interface) *NamespaceSourceQuerier {
 	return &NamespaceSourceQuerier{
 		sources: sources,
 	}
@@ -54,23 +50,23 @@ func (q *NamespaceSourceQuerier) Queryable() error {
 	return nil
 }
 
-func (q *NamespaceSourceQuerier) FindProvider(api opregistry.APIKey, initialSource CatalogKey, excludedPkgName string) (*registryapi.Bundle, *CatalogKey, error) {
+func (q *NamespaceSourceQuerier) FindProvider(api opregistry.APIKey, initialSource CatalogKey) (*api.Bundle, *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, excludedPkgName); err == nil {
+			if bundle, err := source.GetBundleThatProvides(context.TODO(), api.Group, api.Version, api.Kind); err == nil {
 				return bundle, &initialSource, nil
 			}
-			if bundle, err := source.FindBundleThatProvides(context.TODO(), api.Plural+"."+api.Group, api.Version, api.Kind, excludedPkgName); err == nil {
+			if bundle, err := source.GetBundleThatProvides(context.TODO(), api.Plural+"."+api.Group, api.Version, api.Kind); 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, excludedPkgName); err == nil {
+		if bundle, err := source.GetBundleThatProvides(context.TODO(), api.Group, api.Version, api.Kind); err == nil {
 			return bundle, &key, nil
 		}
-		if bundle, err := source.FindBundleThatProvides(context.TODO(), api.Plural+"."+api.Group, api.Version, api.Kind, excludedPkgName); err == nil {
+		if bundle, err := source.GetBundleThatProvides(context.TODO(), api.Plural+"."+api.Group, api.Version, api.Kind); err == nil {
 			return bundle, &key, nil
 		}
 	}
diff --git a/pkg/controller/registry/resolver/resolver.go b/pkg/controller/registry/resolver/resolver.go
index ea551ee25..dbe239ea2 100644
--- a/pkg/controller/registry/resolver/resolver.go
+++ b/pkg/controller/registry/resolver/resolver.go
@@ -1,4 +1,4 @@
-//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_registry_client.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 . Resolver
 package resolver
 
diff --git a/pkg/lib/scoped/querier.go b/pkg/lib/scoped/querier.go
index 00f345674..b285d6d9f 100644
--- a/pkg/lib/scoped/querier.go
+++ b/pkg/lib/scoped/querier.go
@@ -35,7 +35,7 @@ func (f *UserDefinedServiceAccountQuerier) NamespaceQuerier(namespace string) Se
 			logFieldName: logFieldValue,
 		})
 
-		return QueryServiceAccountFromNamespace(logger, f.crclient, namespace)
+		return queryServiceAccountFromNamespace(logger, f.crclient, namespace)
 	}
 
 	return querierFunc
@@ -43,11 +43,11 @@ func (f *UserDefinedServiceAccountQuerier) NamespaceQuerier(namespace string) Se
 
 // QueryServiceAccountFromNamespace will return the reference to a service account
 // associated with the operator group for the given namespace.
-// - If no operator group is found in the namespace, both reference and err are set to nil.
+// - If no operator group is found in the namespace, an error is returned.
 // - If an operator group found is not managing the namespace then it is ignored.
 // - If no operator group is managing this namespace then both reference and err are set to nil.
 // - If more than one operator group are managing this namespace then an error is thrown.
-func QueryServiceAccountFromNamespace(logger *logrus.Entry, crclient versioned.Interface, namespace string) (reference *corev1.ObjectReference, err error) {
+func queryServiceAccountFromNamespace(logger *logrus.Entry, crclient versioned.Interface, namespace string) (reference *corev1.ObjectReference, err error) {
 	// TODO: use a lister instead of a noncached client here.
 	list, err := crclient.OperatorsV1().OperatorGroups(namespace).List(context.TODO(), metav1.ListOptions{})
 	if err != nil {
@@ -55,7 +55,7 @@ func QueryServiceAccountFromNamespace(logger *logrus.Entry, crclient versioned.I
 	}
 
 	if len(list.Items) == 0 {
-		logger.Warnf("list query returned an empty list")
+		err = fmt.Errorf("no operator group found that is managing this namespace")
 		return
 	}
 
@@ -70,7 +70,7 @@ func QueryServiceAccountFromNamespace(logger *logrus.Entry, crclient versioned.I
 	}
 
 	if len(groups) == 0 {
-		logger.Warn("no operator group found that is managing this namespace")
+		err = fmt.Errorf("no operator group found that is managing this namespace")
 		return
 	}
 
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 8e6e656de..8253155ad 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -503,6 +503,7 @@ github.com/russross/blackfriday/v2
 github.com/shurcooL/sanitized_anchor_name
 # github.com/sirupsen/logrus v1.4.2
 github.com/sirupsen/logrus
+github.com/sirupsen/logrus/hooks/test
 # github.com/spf13/cast v1.3.1
 github.com/spf13/cast
 # github.com/spf13/cobra v1.0.0


Test patch:
diff --git a/pkg/controller/operators/catalog/operator_test.go b/pkg/controller/operators/catalog/operator_test.go
index 4ecebcbe8..ee883c508 100644
--- a/pkg/controller/operators/catalog/operator_test.go
+++ b/pkg/controller/operators/catalog/operator_test.go
@@ -135,6 +135,57 @@ func TestTransitionInstallPlan(t *testing.T) {
 	}
 }
 
+func TestSyncInstallPlanUnhappy(t *testing.T) {
+	namespace := "ns"
+
+	tests := []struct {
+		testName string
+		in       *v1alpha1.InstallPlan
+		err      error
+	}{
+		{
+			testName: "NoStatus",
+			in:       installPlan("p", namespace, v1alpha1.InstallPlanPhaseNone),
+			err:      nil,
+		},
+		{
+			// This checks that installplans are not applied when no operatorgroup is present
+			testName: "HasSteps/NoOperatorGroup",
+			in: withSteps(installPlan("p", namespace, v1alpha1.InstallPlanPhaseInstalling, "csv"),
+				[]*v1alpha1.Step{
+					{
+						Resource: v1alpha1.StepResource{
+							CatalogSource:          "catalog",
+							CatalogSourceNamespace: namespace,
+							Group:                  "",
+							Version:                "v1",
+							Kind:                   "ServiceAccount",
+							Name:                   "sa",
+							Manifest: toManifest(t, serviceAccount("sa", namespace, "",
+								objectReference("init secret"))),
+						},
+						Status: v1alpha1.StepStatusUnknown,
+					},
+				},
+			),
+			err:  fmt.Errorf("attenuated service account query failed - no operator group found that is managing this namespace"),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.testName, func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.TODO())
+			defer cancel()
+
+			op, err := NewFakeOperator(ctx, namespace, []string{namespace}, withClientObjs(tt.in))
+			require.NoError(t, err)
+
+			err = op.syncInstallPlans(tt.in)
+			require.Equal(t, tt.err, err)
+		})
+	}
+}
+
 func TestExecutePlan(t *testing.T) {
 	namespace := "ns"
 
diff --git a/pkg/controller/registry/resolver/querier_test.go b/pkg/controller/registry/resolver/querier_test.go
index a70233b88..a5d013a41 100644
--- a/pkg/controller/registry/resolver/querier_test.go
+++ b/pkg/controller/registry/resolver/querier_test.go
@@ -13,24 +13,18 @@ import (
 	"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/registry"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/fakes"
+	"github.com/operator-framework/api/pkg/lib/version"
 )
 
 func TestNewNamespaceSourceQuerier(t *testing.T) {
-	emptySources := map[CatalogKey]registry.ClientInterface{}
-	nonEmptySources := map[CatalogKey]registry.ClientInterface{
-		CatalogKey{"test", "ns"}: &registry.Client{
-			Client: &client.Client{
-				Registry: &fakes.FakeRegistryClient{},
-			},
-		},
+	emptySources := map[CatalogKey]client.Interface{}
+	nonEmptySources := map[CatalogKey]client.Interface{
+		CatalogKey{"test", "ns"}: &fakes.FakeInterface{},
 	}
-
 	type args struct {
-		sources map[CatalogKey]registry.ClientInterface
+		sources map[CatalogKey]client.Interface
 	}
 	tests := []struct {
 		name string
@@ -68,7 +62,7 @@ func TestNewNamespaceSourceQuerier(t *testing.T) {
 
 func TestNamespaceSourceQuerier_Queryable(t *testing.T) {
 	type fields struct {
-		sources map[CatalogKey]registry.ClientInterface
+		sources map[CatalogKey]client.Interface
 	}
 	tests := []struct {
 		name   string
@@ -85,19 +79,15 @@ func TestNamespaceSourceQuerier_Queryable(t *testing.T) {
 		{
 			name: "empty",
 			fields: fields{
-				sources: map[CatalogKey]registry.ClientInterface{},
+				sources: map[CatalogKey]client.Interface{},
 			},
 			error: fmt.Errorf("no catalog sources available"),
 		},
 		{
 			name: "nonEmpty",
 			fields: fields{
-				sources: map[CatalogKey]registry.ClientInterface{
-					CatalogKey{"test", "ns"}: &registry.Client{
-						Client: &client.Client{
-							Registry: &fakes.FakeRegistryClient{},
-						},
-					},
+				sources: map[CatalogKey]client.Interface{
+					CatalogKey{"test", "ns"}: &fakes.FakeInterface{},
 				},
 			},
 			error: nil,
@@ -115,12 +105,13 @@ func TestNamespaceSourceQuerier_Queryable(t *testing.T) {
 }
 
 func TestNamespaceSourceQuerier_FindProvider(t *testing.T) {
-	fakeSource := fakes.FakeClientInterface{}
-	fakeSource2 := fakes.FakeClientInterface{}
-	sources := map[CatalogKey]registry.ClientInterface{
+	fakeSource := fakes.FakeInterface{}
+	fakeSource2 := fakes.FakeInterface{}
+	sources := map[CatalogKey]client.Interface{
 		CatalogKey{"test", "ns"}:  &fakeSource,
 		CatalogKey{"test2", "ns"}: &fakeSource2,
 	}
+
 	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) {
@@ -135,21 +126,9 @@ func TestNamespaceSourceQuerier_FindProvider(t *testing.T) {
 		}
 		return bundle2, nil
 	}
-	fakeSource.FindBundleThatProvidesStub = func(ctx context.Context, group, version, kind, pkgName string) (*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, pkgName string) (*api.Bundle, error) {
-		if group != "group2" || version != "version2" || kind != "kind2" {
-			return nil, fmt.Errorf("Not Found")
-		}
-		return bundle2, nil
-	}
 
 	type fields struct {
-		sources map[CatalogKey]registry.ClientInterface
+		sources map[CatalogKey]client.Interface
 	}
 	type args struct {
 		api        opregistry.APIKey
@@ -228,7 +207,7 @@ func TestNamespaceSourceQuerier_FindProvider(t *testing.T) {
 			q := &NamespaceSourceQuerier{
 				sources: tt.fields.sources,
 			}
-			bundle, key, err := q.FindProvider(tt.args.api, tt.args.catalogKey, "")
+			bundle, key, err := q.FindProvider(tt.args.api, tt.args.catalogKey)
 			require.Equal(t, tt.out.err, err)
 			require.Equal(t, tt.out.bundle, bundle)
 			require.Equal(t, tt.out.key, key)
@@ -237,8 +216,8 @@ func TestNamespaceSourceQuerier_FindProvider(t *testing.T) {
 }
 
 func TestNamespaceSourceQuerier_FindPackage(t *testing.T) {
-	initialSource := fakes.FakeClientInterface{}
-	otherSource := fakes.FakeClientInterface{}
+	initialSource := fakes.FakeInterface{}
+	otherSource := fakes.FakeInterface{}
 	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"}
@@ -262,13 +241,13 @@ func TestNamespaceSourceQuerier_FindPackage(t *testing.T) {
 	}
 	initialKey := CatalogKey{"initial", "ns"}
 	otherKey := CatalogKey{"other", "other"}
-	sources := map[CatalogKey]registry.ClientInterface{
+	sources := map[CatalogKey]client.Interface{
 		initialKey: &initialSource,
 		otherKey:   &otherSource,
 	}
 
 	type fields struct {
-		sources map[CatalogKey]registry.ClientInterface
+		sources map[CatalogKey]client.Interface
 	}
 	type args struct {
 		pkgName       string
@@ -346,11 +325,11 @@ func TestNamespaceSourceQuerier_FindPackage(t *testing.T) {
 
 func TestNamespaceSourceQuerier_FindReplacement(t *testing.T) {
 	// TODO: clean up this test setup
-	initialSource := fakes.FakeClientInterface{}
-	otherSource := fakes.FakeClientInterface{}
-	replacementSource := fakes.FakeClientInterface{}
-	replacementAndLatestSource := fakes.FakeClientInterface{}
-	replacementAndNoAnnotationLatestSource := fakes.FakeClientInterface{}
+	initialSource := fakes.FakeInterface{}
+	otherSource := fakes.FakeInterface{}
+	replacementSource := fakes.FakeInterface{}
+	replacementAndLatestSource := fakes.FakeInterface{}
+	replacementAndNoAnnotationLatestSource := fakes.FakeInterface{}
 
 	latestVersion := semver.MustParse("1.0.0-1556661308")
 	csv := v1alpha1.ClusterServiceVersion{
@@ -425,7 +404,7 @@ func TestNamespaceSourceQuerier_FindReplacement(t *testing.T) {
 	replacementAndLatestKey := CatalogKey{"replat", "ns"}
 	replacementAndNoAnnotationLatestKey := CatalogKey{"replatbad", "ns"}
 
-	sources := map[CatalogKey]registry.ClientInterface{
+	sources := map[CatalogKey]client.Interface{
 		initialKey:                          &initialSource,
 		otherKey:                            &otherSource,
 		replacementKey:                      &replacementSource,
@@ -437,7 +416,7 @@ func TestNamespaceSourceQuerier_FindReplacement(t *testing.T) {
 	notInRange := semver.MustParse("1.0.0-1556661347")
 
 	type fields struct {
-		sources map[CatalogKey]registry.ClientInterface
+		sources map[CatalogKey]client.Interface
 	}
 	type args struct {
 		currentVersion *semver.Version
diff --git a/pkg/controller/registry/resolver/util_test.go b/pkg/controller/registry/resolver/util_test.go
index 1d3f41cfd..2498fb572 100644
--- a/pkg/controller/registry/resolver/util_test.go
+++ b/pkg/controller/registry/resolver/util_test.go
@@ -9,6 +9,7 @@ import (
 
 	"github.com/blang/semver"
 	"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"
 	appsv1 "k8s.io/api/apps/v1"
@@ -19,7 +20,6 @@ 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/fakes"
 )
 
@@ -312,9 +312,9 @@ func withReplaces(operator *Operator, replaces string) *Operator {
 
 // NewFakeSourceQuerier builds a querier that talks to fake registry stubs for testing
 func NewFakeSourceQuerier(bundlesByCatalog map[CatalogKey][]*api.Bundle) *NamespaceSourceQuerier {
-	sources := map[CatalogKey]registry.ClientInterface{}
+	sources := map[CatalogKey]client.Interface{}
 	for catKey, bundles := range bundlesByCatalog {
-		source := &fakes.FakeClientInterface{}
+		source := &fakes.FakeInterface{}
 		source.GetBundleThatProvidesStub = func(ctx context.Context, groupOrName, version, kind string) (*api.Bundle, error) {
 			for _, b := range bundles {
 				apis := b.GetProvidedApis()
@@ -356,98 +356,17 @@ func NewFakeSourceQuerier(bundlesByCatalog map[CatalogKey][]*api.Bundle) *Namesp
 					return b, nil
 				}
 			}
-
 			return nil, fmt.Errorf("no bundle found")
 		}
-
-		source.FindBundleThatProvidesStub = func(ctx context.Context, groupOrName, version, kind, pkgName string) (*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 pkgname == pkgName {
-					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]
-}
-
 // NewFakeSourceQuerier builds a querier that talks to fake registry stubs for testing
 func NewFakeSourceQuerierCustomReplacement(catKey CatalogKey, bundle *api.Bundle) *NamespaceSourceQuerier {
-	sources := map[CatalogKey]registry.ClientInterface{}
-	source := &fakes.FakeClientInterface{}
+	sources := map[CatalogKey]client.Interface{}
+	source := &fakes.FakeInterface{}
 	source.GetBundleThatProvidesStub = func(ctx context.Context, groupOrName, version, kind string) (*api.Bundle, error) {
 		return nil, fmt.Errorf("no bundle found")
 	}
diff --git a/pkg/lib/scoped/querier_test.go b/pkg/lib/scoped/querier_test.go
new file mode 100644
index 000000000..e65a7760d
--- /dev/null
+++ b/pkg/lib/scoped/querier_test.go
@@ -0,0 +1,159 @@
+package scoped
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/require"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	v1 "github.com/operator-framework/api/pkg/operators/v1"
+	"github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned"
+	"github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned/fake"
+)
+
+func TestUserDefinedServiceAccountQuerier(t *testing.T) {
+	tests := []struct {
+		name          string
+		crclient      versioned.Interface
+		namespace     string
+		wantReference *corev1.ObjectReference
+		wantErr       bool
+		err           error
+	}{
+		{
+			name:      "NoOperatorGroup",
+			crclient:  fake.NewSimpleClientset(),
+			namespace: "ns",
+			wantErr:   true,
+			err:       fmt.Errorf("no operator group found that is managing this namespace"),
+		},
+		{
+			name: "OperatorGroup/NamespaceNotInSpec",
+			crclient: fake.NewSimpleClientset(&v1.OperatorGroup{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "og",
+					Namespace: "ns",
+				},
+				Spec: v1.OperatorGroupSpec{
+					TargetNamespaces: []string{"other"},
+				},
+			}),
+			namespace: "ns",
+			wantErr:   true,
+			err:       fmt.Errorf("no operator group found that is managing this namespace"),
+		},
+		{
+			name: "OperatorGroup/NamespaceNotInStatus",
+			crclient: fake.NewSimpleClientset(&v1.OperatorGroup{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "og",
+					Namespace: "ns",
+				},
+				Spec: v1.OperatorGroupSpec{
+					TargetNamespaces: []string{"ns"},
+				},
+			}),
+			namespace: "ns",
+			wantErr:   true,
+			err:       fmt.Errorf("no operator group found that is managing this namespace"),
+		},
+		{
+			name: "OperatorGroup/Multiple",
+			crclient: fake.NewSimpleClientset(
+				&v1.OperatorGroup{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:      "og",
+						Namespace: "ns",
+					},
+					Spec: v1.OperatorGroupSpec{
+						TargetNamespaces: []string{"ns"},
+					},
+					Status: v1.OperatorGroupStatus{
+						Namespaces: []string{"ns"},
+					},
+				},
+				&v1.OperatorGroup{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:      "og2",
+						Namespace: "ns",
+					},
+					Spec: v1.OperatorGroupSpec{
+						TargetNamespaces: []string{"ns"},
+					},
+					Status: v1.OperatorGroupStatus{
+						Namespaces: []string{"ns"},
+					},
+				},
+			),
+			namespace: "ns",
+			wantErr:   true,
+			err:       fmt.Errorf("more than one operator group(s) are managing this namespace count=2"),
+		},
+		{
+			name: "OperatorGroup/NamespaceInStatus/NoSA",
+			crclient: fake.NewSimpleClientset(&v1.OperatorGroup{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "og",
+					Namespace: "ns",
+				},
+				Spec: v1.OperatorGroupSpec{
+					TargetNamespaces: []string{"ns"},
+				},
+				Status: v1.OperatorGroupStatus{
+					Namespaces: []string{"ns"},
+				},
+			}),
+			namespace: "ns",
+			wantErr:   false,
+			err:       nil,
+		},
+		{
+			name: "OperatorGroup/NamespaceInStatus/ServiceAccountRef",
+			crclient: fake.NewSimpleClientset(&v1.OperatorGroup{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "og",
+					Namespace: "ns",
+				},
+				Spec: v1.OperatorGroupSpec{
+					TargetNamespaces:   []string{"ns"},
+					ServiceAccountName: "sa",
+				},
+				Status: v1.OperatorGroupStatus{
+					Namespaces: []string{"ns"},
+					ServiceAccountRef: &corev1.ObjectReference{
+						Kind:      "ServiceAccount",
+						Namespace: "ns",
+						Name:      "sa",
+					},
+				},
+			}),
+			namespace: "ns",
+			wantErr:   false,
+			err:       nil,
+			wantReference: &corev1.ObjectReference{
+				Kind:      "ServiceAccount",
+				Namespace: "ns",
+				Name:      "sa",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			logger, _ := test.NewNullLogger()
+			f := &UserDefinedServiceAccountQuerier{
+				crclient: tt.crclient,
+				logger:   logger,
+			}
+			gotReference, err := f.NamespaceQuerier(tt.namespace)()
+			if tt.wantErr {
+				require.Equal(t, tt.err, err)
+			} else {
+				require.Nil(t, tt.err)
+			}
+			require.Equal(t, tt.wantReference, gotReference)
+		})
+	}
+}
diff --git a/test/e2e/installplan_e2e_test.go b/test/e2e/installplan_e2e_test.go
index 00d08446c..c5e79441b 100644
--- a/test/e2e/installplan_e2e_test.go
+++ b/test/e2e/installplan_e2e_test.go
@@ -340,6 +340,7 @@ var _ = Describe("Install Plan", func() {
 			mainPackageStable := fmt.Sprintf("%s-stable", mainPackageName)
 			mainPackageBeta := fmt.Sprintf("%s-beta", mainPackageName)
 			dependentPackageStable := fmt.Sprintf("%s-stable", dependentPackageName)
+			dependentPackageBeta := fmt.Sprintf("%s-beta", dependentPackageName)
 
 			stableChannel := "stable"
 			betaChannel := "beta"
@@ -358,6 +359,7 @@ var _ = Describe("Install Plan", func() {
 					PackageName: dependentPackageName,
 					Channels: []registry.PackageChannel{
 						{Name: stableChannel, CurrentCSVName: dependentPackageStable},
+						{Name: betaChannel, CurrentCSVName: dependentPackageBeta},
 					},
 					DefaultChannelName: stableChannel,
 				},
@@ -378,6 +380,7 @@ var _ = Describe("Install Plan", func() {
 			mainStableCSV := newCSV(mainPackageStable, testNamespace, "", semver.MustParse("0.1.0"), []apiextensions.CustomResourceDefinition{mainCRD}, []apiextensions.CustomResourceDefinition{dependentCRD}, mainNamedStrategy)
 			mainBetaCSV := newCSV(mainPackageBeta, testNamespace, mainPackageStable, semver.MustParse("0.2.0"), []apiextensions.CustomResourceDefinition{mainCRD}, []apiextensions.CustomResourceDefinition{dependentCRD}, mainNamedStrategy)
 			dependentStableCSV := newCSV(dependentPackageStable, testNamespace, "", semver.MustParse("0.1.0"), []apiextensions.CustomResourceDefinition{dependentCRD}, nil, dependentNamedStrategy)
+			dependentBetaCSV := newCSV(dependentPackageBeta, testNamespace, dependentPackageStable, semver.MustParse("0.2.0"), []apiextensions.CustomResourceDefinition{dependentCRD}, nil, dependentNamedStrategy)
 
 			c := newKubeClient()
 			crc := newCRClient()
@@ -387,7 +390,7 @@ var _ = Describe("Install Plan", func() {
 
 			// Create the catalog source
 			mainCatalogSourceName := genName("mock-ocs-main-" + strings.ToLower(CurrentGinkgoTestDescription().TestText) + "-")
-			_, cleanupCatalogSource := createInternalCatalogSource(c, crc, mainCatalogSourceName, testNamespace, mainManifests, []apiextensions.CustomResourceDefinition{dependentCRD, mainCRD}, []operatorsv1alpha1.ClusterServiceVersion{dependentStableCSV, mainStableCSV, mainBetaCSV})
+			_, cleanupCatalogSource := createInternalCatalogSource(c, crc, mainCatalogSourceName, testNamespace, mainManifests, []apiextensions.CustomResourceDefinition{dependentCRD, mainCRD}, []operatorsv1alpha1.ClusterServiceVersion{dependentBetaCSV, dependentStableCSV, mainStableCSV, mainBetaCSV})
 			defer cleanupCatalogSource()
 
 			// Attempt to get the catalog source before creating install plan(s)
@@ -2398,6 +2401,11 @@ var _ = Describe("Install Plan", func() {
 		}, metav1.CreateOptions{})
 		require.NoError(GinkgoT(), err)
 
+		og := &operatorsv1.OperatorGroup{}
+		og.SetName("og")
+		_, err = crc.OperatorsV1().OperatorGroups(ns.GetName()).Create(context.TODO(), og, metav1.CreateOptions{})
+		require.NoError(GinkgoT(), err)
+
 		deleteOpts := &metav1.DeleteOptions{}
 		defer func() {
 			require.NoError(GinkgoT(), c.KubernetesInterface().CoreV1().Namespaces().Delete(context.TODO(), ns.GetName(), *deleteOpts))
@@ -2618,7 +2626,75 @@ var _ = Describe("Install Plan", func() {
 		require.NoError(GinkgoT(), err)
 		require.Equal(GinkgoT(), 1, len(ips.Items), "If this test fails it should be taken seriously and not treated as a flake. \n%v", ips.Items)
 	})
+	
+	It("without an operatorgroup", func() {
+		defer cleaner.NotifyTestComplete(true)
+
+		log := func(s string) {
+			GinkgoT().Logf("%s: %s", time.Now().Format("15:04:05.9999"), s)
+		}
+
+		ns := &corev1.Namespace{}
+		ns.SetName(genName("ns-"))
+
+		c := newKubeClient()
+		crc := newCRClient()
+
+		// Create a namespace
+		ns, err := c.KubernetesInterface().CoreV1().Namespaces().Create(context.TODO(), ns, metav1.CreateOptions{})
+		require.NoError(GinkgoT(), err)
+		deleteOpts := &metav1.DeleteOptions{}
+		defer func() {
+			require.NoError(GinkgoT(), c.KubernetesInterface().CoreV1().Namespaces().Delete(context.TODO(), ns.GetName(), *deleteOpts))
+		}()
+
+		mainPackageName := genName("nginx-")
+		mainPackageStable := fmt.Sprintf("%s-stable", mainPackageName)
+		stableChannel := "stable"
+		mainNamedStrategy := newNginxInstallStrategy(genName("dep-"), nil, nil)
+		mainCSV := newCSV(mainPackageStable, ns.GetName(), "", semver.MustParse("0.1.0"), nil, nil, mainNamedStrategy)
+
+		defer func() {
+			require.NoError(GinkgoT(), crc.OperatorsV1alpha1().Subscriptions(ns.GetName()).DeleteCollection(context.TODO(), metav1.DeleteOptions{}, metav1.ListOptions{}))
+		}()
 
+		mainCatalogName := genName("mock-ocs-main-")
+		mainManifests := []registry.PackageManifest{
+			{
+				PackageName: mainPackageName,
+				Channels: []registry.PackageChannel{
+					{Name: stableChannel, CurrentCSVName: mainPackageStable},
+				},
+				DefaultChannelName: stableChannel,
+			},
+		}
+
+		// Create the main catalog source
+		_, cleanupMainCatalogSource := createInternalCatalogSource(c, crc, mainCatalogName, ns.GetName(), mainManifests, nil, []operatorsv1alpha1.ClusterServiceVersion{mainCSV})
+		defer cleanupMainCatalogSource()
+
+		// Attempt to get the catalog source before creating install plan
+		_, err = fetchCatalogSourceOnStatus(crc, mainCatalogName, ns.GetName(), catalogSourceRegistryPodSynced)
+		require.NoError(GinkgoT(), err)
+
+		subscriptionName := genName("sub-nginx-")
+		subscriptionCleanup := createSubscriptionForCatalog(crc, ns.GetName(), subscriptionName, mainCatalogName, mainPackageName, stableChannel, "", operatorsv1alpha1.ApprovalAutomatic)
+		defer subscriptionCleanup()
+
+		subscription, err := fetchSubscription(crc, ns.GetName(), subscriptionName, subscriptionHasInstallPlanChecker)
+		require.NoError(GinkgoT(), err)
+		require.NotNil(GinkgoT(), subscription)
+
+		installPlanName := subscription.Status.InstallPlanRef.Name
+
+		fetchedInstallPlan, err := fetchInstallPlanWithNamespace(GinkgoT(), crc, installPlanName, ns.GetName(), buildInstallPlanPhaseCheckFunc(operatorsv1alpha1.InstallPlanPhaseInstalling))
+		require.NoError(GinkgoT(), err)
+		log(fmt.Sprintf("Install plan %s fetched with status %s", fetchedInstallPlan.GetName(), fetchedInstallPlan.Status.Phase))
+
+		fetchedInstallPlan, err = fetchInstallPlanWithNamespace(GinkgoT(), crc, installPlanName, ns.GetName(), buildInstallPlanPhaseCheckFunc(operatorsv1alpha1.InstallPlanPhaseInstalling))
+		require.NoError(GinkgoT(), err)
+		log(fmt.Sprintf("Install plan %s fetched with status %s", fetchedInstallPlan.GetName(), fetchedInstallPlan.Status.Phase))
+	})
 })
 
 type checkInstallPlanFunc func(fip *operatorsv1alpha1.InstallPlan) bool
diff --git a/test/e2e/operator_groups_e2e_test.go b/test/e2e/operator_groups_e2e_test.go
index 5a089a48f..cb3ff0706 100644
--- a/test/e2e/operator_groups_e2e_test.go
+++ b/test/e2e/operator_groups_e2e_test.go
@@ -7,8 +7,6 @@ import (
 	"time"
 
 	"github.com/blang/semver"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
 	"github.com/stretchr/testify/require"
 	authorizationv1 "k8s.io/api/authorization/v1"
 	corev1 "k8s.io/api/core/v1"
@@ -23,6 +21,7 @@ import (
 	"k8s.io/client-go/tools/cache"
 	"k8s.io/client-go/util/retry"
 
+	. "github.com/onsi/ginkgo"
 	v1 "github.com/operator-framework/api/pkg/operators/v1"
 	"github.com/operator-framework/api/pkg/operators/v1alpha1"
 	"github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned"
@@ -2108,7 +2107,7 @@ var _ = Describe("Operator Group", func() {
 			LabelSelector: labels.Set(map[string]string{ogLabel: ""}).String(),
 		}
 
-		namespaceList, err := pollForNamespaceListCount(c, listOptions, 0)
+		namespaceList, err := pollForListCount(c, listOptions, 0)
 		require.NoError(GinkgoT(), err)
 
 		// Update the OperatorGroup to include a single namespace
@@ -2116,7 +2115,7 @@ var _ = Describe("Operator Group", func() {
 		updateOGSpecFunc := updateOperatorGroupSpecFunc(GinkgoT(), crc, testNamespaceA, operatorGroup.GetName())
 		require.NoError(GinkgoT(), retry.RetryOnConflict(retry.DefaultBackoff, updateOGSpecFunc(operatorGroup.Spec)))
 
-		namespaceList, err = pollForNamespaceListCount(c, listOptions, 1)
+		namespaceList, err = pollForListCount(c, listOptions, 1)
 		require.NoError(GinkgoT(), err)
 		require.True(GinkgoT(), checkForOperatorGroupLabels(operatorGroup, namespaceList.Items))
 
@@ -2124,7 +2123,7 @@ var _ = Describe("Operator Group", func() {
 		operatorGroup.Spec.TargetNamespaces = []string{testNamespaceA, testNamespaceC}
 		require.NoError(GinkgoT(), retry.RetryOnConflict(retry.DefaultBackoff, updateOGSpecFunc(operatorGroup.Spec)))
 
-		namespaceList, err = pollForNamespaceListCount(c, listOptions, 2)
+		namespaceList, err = pollForListCount(c, listOptions, 2)
 		require.NoError(GinkgoT(), err)
 		require.True(GinkgoT(), checkForOperatorGroupLabels(operatorGroup, namespaceList.Items))
 
@@ -2132,7 +2131,7 @@ var _ = Describe("Operator Group", func() {
 		operatorGroup.Spec.TargetNamespaces = []string{testNamespaceA, testNamespaceB, testNamespaceC}
 		require.NoError(GinkgoT(), retry.RetryOnConflict(retry.DefaultBackoff, updateOGSpecFunc(operatorGroup.Spec)))
 
-		namespaceList, err = pollForNamespaceListCount(c, listOptions, 3)
+		namespaceList, err = pollForListCount(c, listOptions, 3)
 		require.NoError(GinkgoT(), err)
 		require.True(GinkgoT(), checkForOperatorGroupLabels(operatorGroup, namespaceList.Items))
 
@@ -2140,7 +2139,7 @@ var _ = Describe("Operator Group", func() {
 		operatorGroup.Spec.TargetNamespaces = []string{testNamespaceA, testNamespaceC}
 		require.NoError(GinkgoT(), retry.RetryOnConflict(retry.DefaultBackoff, updateOGSpecFunc(operatorGroup.Spec)))
 
-		namespaceList, err = pollForNamespaceListCount(c, listOptions, 2)
+		namespaceList, err = pollForListCount(c, listOptions, 2)
 		require.NoError(GinkgoT(), err)
 		require.True(GinkgoT(), checkForOperatorGroupLabels(operatorGroup, namespaceList.Items))
 
@@ -2148,7 +2147,7 @@ var _ = Describe("Operator Group", func() {
 		operatorGroup.Spec.TargetNamespaces = []string{}
 		require.NoError(GinkgoT(), retry.RetryOnConflict(retry.DefaultBackoff, updateOGSpecFunc(operatorGroup.Spec)))
 
-		namespaceList, err = pollForNamespaceListCount(c, listOptions, 0)
+		namespaceList, err = pollForListCount(c, listOptions, 0)
 		require.NoError(GinkgoT(), err)
 	})
 	It("CleanupDeletedOperatorGroupLabels", func() {
@@ -2203,7 +2202,7 @@ var _ = Describe("Operator Group", func() {
 			LabelSelector: labels.Set(map[string]string{ogLabel: ""}).String(),
 		}
 
-		namespaceList, err := pollForNamespaceListCount(c, listOptions, 3)
+		namespaceList, err := pollForListCount(c, listOptions, 3)
 		require.NoError(GinkgoT(), err)
 		require.True(GinkgoT(), checkForOperatorGroupLabels(operatorGroup, namespaceList.Items))
 
@@ -2212,149 +2211,9 @@ var _ = Describe("Operator Group", func() {
 		require.NoError(GinkgoT(), err)
 
 		// Check that no namespaces have the OperatorGroup.
-		namespaceList, err = pollForNamespaceListCount(c, listOptions, 0)
+		namespaceList, err = pollForListCount(c, listOptions, 0)
 		require.NoError(GinkgoT(), err)
 	})
-
-	Context("Given a set of Namespaces", func() {
-
-		var (
-			c              operatorclient.ClientInterface
-			crc            versioned.Interface
-			testNamespaces []string
-			testNamespaceA string
-		)
-
-		BeforeEach(func() {
-			c = newKubeClient()
-			crc = newCRClient()
-
-			// Create the namespaces that will have an OperatorGroup Label applied.
-			testNamespaceA = genName("namespace-a-")
-			testNamespaceB := genName("namespace-b-")
-			testNamespaceC := genName("namespace-c-")
-			testNamespaces = []string{
-				testNamespaceA, testNamespaceB, testNamespaceC,
-			}
-
-			// Create the namespaces
-			for _, namespace := range testNamespaces {
-				_, err := c.KubernetesInterface().CoreV1().Namespaces().Create(context.TODO(), &corev1.Namespace{
-					ObjectMeta: metav1.ObjectMeta{
-						Name: namespace,
-					},
-				}, metav1.CreateOptions{})
-				Expect(err).ToNot(HaveOccurred())
-			}
-		})
-
-		AfterEach(func() {
-			// Cleanup namespaces
-			for _, namespace := range testNamespaces {
-				err := c.KubernetesInterface().CoreV1().Namespaces().Delete(context.TODO(), namespace, metav1.DeleteOptions{})
-				Expect(err).ToNot(HaveOccurred())
-			}
-		})
-
-		Context("Associating these Namespaces with a label", func() {
-
-			var (
-				matchingLabel map[string]string
-			)
-
-			BeforeEach(func() {
-
-				matchingLabel = map[string]string{"foo": "bar"}
-
-				// Updating Namespace with labels
-				for _, namespace := range testNamespaces {
-					_, err := c.KubernetesInterface().CoreV1().Namespaces().Update(context.TODO(), &corev1.Namespace{
-						ObjectMeta: metav1.ObjectMeta{
-							Name:   namespace,
-							Labels: matchingLabel,
-						},
-					}, metav1.UpdateOptions{})
-					Expect(err).ToNot(HaveOccurred())
-				}
-
-			})
-
-			When("an OperatorGroup is created having matching label selector defined", func() {
-				var operatorGroup *v1.OperatorGroup
-
-				BeforeEach(func() {
-
-					// Creating operator group
-					operatorGroup = &v1.OperatorGroup{
-						ObjectMeta: metav1.ObjectMeta{
-							Name:      genName("e2e-operator-group-"),
-							Namespace: testNamespaceA,
-						},
-						Spec: v1.OperatorGroupSpec{
-							Selector: &metav1.LabelSelector{
-								MatchLabels: matchingLabel,
-							},
-						},
-					}
-					var err error
-					operatorGroup, err = crc.OperatorsV1().OperatorGroups(testNamespaceA).Create(context.TODO(), operatorGroup, metav1.CreateOptions{})
-					Expect(err).ToNot(HaveOccurred())
-				})
-
-				It("OLM applies labels to Namespaces that are associated with an OperatorGroup", func() {
-					ogLabel, err := getOGLabelKey(operatorGroup)
-					Expect(err).ToNot(HaveOccurred())
-
-					// Create list options
-					listOptions := metav1.ListOptions{
-						LabelSelector: labels.Set(map[string]string{ogLabel: ""}).String(),
-					}
-
-					// Verify that all the namespaces listed in targetNamespaces field of OperatorGroup have labels applied on them
-					namespaceList, err := pollForNamespaceListCount(c, listOptions, 3)
-					Expect(err).ToNot(HaveOccurred())
-					Expect(checkForOperatorGroupLabels(operatorGroup, namespaceList.Items)).Should(BeTrue())
-				})
-			})
-		})
-
-		When("an OperatorGroup is created having above Namespaces defined under targetNamespaces field", func() {
-			var operatorGroup *v1.OperatorGroup
-
-			BeforeEach(func() {
-				// Create an OperatorGroup with three target namespaces.
-				operatorGroup = &v1.OperatorGroup{
-					ObjectMeta: metav1.ObjectMeta{
-						Name:      genName("e2e-operator-group-"),
-						Namespace: testNamespaceA,
-					},
-					Spec: v1.OperatorGroupSpec{
-						TargetNamespaces: testNamespaces,
-					},
-				}
-				var err error
-				operatorGroup, err = crc.OperatorsV1().OperatorGroups(testNamespaceA).Create(context.TODO(), operatorGroup, metav1.CreateOptions{})
-				Expect(err).ToNot(HaveOccurred())
-			})
-
-			It("OLM applies labels to Namespaces that are associated with an OperatorGroup", func() {
-
-				ogLabel, err := getOGLabelKey(operatorGroup)
-				Expect(err).ToNot(HaveOccurred())
-
-				// Create list options
-				listOptions := metav1.ListOptions{
-					LabelSelector: labels.Set(map[string]string{ogLabel: ""}).String(),
-				}
-
-				// Verify that all the namespaces listed in targetNamespaces field of OperatorGroup have labels applied on them
-				namespaceList, err := pollForNamespaceListCount(c, listOptions, 3)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(checkForOperatorGroupLabels(operatorGroup, namespaceList.Items)).Should(BeTrue())
-
-			})
-		})
-	})
 })
 
 func checkOperatorGroupAnnotations(obj metav1.Object, op *v1.OperatorGroup, checkTargetNamespaces bool, targetNamespaces string) error {
@@ -2449,9 +2308,8 @@ func updateOperatorGroupSpecFunc(t GinkgoTInterface, crc versioned.Interface, na
 	}
 }
 
-func pollForNamespaceListCount(c operatorclient.ClientInterface, listOptions metav1.ListOptions, expectedLength int) (list *corev1.NamespaceList, err error) {
-
-	Eventually(func() (bool, error) {
+func pollForListCount(c operatorclient.ClientInterface, listOptions metav1.ListOptions, expectedLength int) (list *corev1.NamespaceList, err error) {
+	wait.PollImmediate(pollInterval, pollDuration, func() (bool, error) {
 		list, err = c.KubernetesInterface().CoreV1().Namespaces().List(context.TODO(), listOptions)
 		if err != nil {
 			return false, err
@@ -2460,7 +2318,7 @@ func pollForNamespaceListCount(c operatorclient.ClientInterface, listOptions met
 			return true, nil
 		}
 		return false, nil
-	}).Should(BeTrue())
+	})
 	return
 }
 
diff --git a/test/e2e/subscription_e2e_test.go b/test/e2e/subscription_e2e_test.go
index 041d4f801..ca87cb0bb 100644
--- a/test/e2e/subscription_e2e_test.go
+++ b/test/e2e/subscription_e2e_test.go
@@ -1253,182 +1253,6 @@ var _ = Describe("Subscription", func() {
 		require.NoError(GinkgoT(), err)
 		require.Len(GinkgoT(), installPlan.Status.CatalogSources, 1)
 	})
-
-	// CatSrc:
-	//
-	// Package A (apackage)
-	// Default Channel: Stable
-	// Channel Stable:
-	// Operator A (Requires: CRD 1, CRD 2 )
-	// Channel Alpha:
-	// Operator ABC (Provides: CRD 1, CRD 2 )
-	// Package B (apackage)
-	// Default Channel: Stable
-	// Channel Stable:
-	// Operator B (Provides: CRD)
-	// CatSrc2:
-	//
-	// Package B (bpackage)
-	// Default Channel: Stable
-	// Channel Stable:
-	// Operator C (Provides: CRD 2)
-	// Then create a subscription:
-	//
-	// CatalogSource: CatSrc
-	// Package: Package A,
-	// Channel: Stable,
-	// StartingCSV: CSV A
-	//
-	// Check installed:
-	//
-	// CSV A, CSV B, CSV C
-	//
-	// CSV A required B and C but didn't get them from Package A
-	It("creation with dependencies required and provided in different versions of an operator in the same package", func() {
-
-		defer cleaner.NotifyTestComplete(true)
-
-		kubeClient := newKubeClient()
-		crClient := newCRClient()
-
-		permissions := deploymentPermissions()
-
-		crdPlural := genName("ins")
-		crdName := crdPlural + ".cluster.com"
-		crdPlural2 := genName("ins")
-		crdName2 := crdPlural2 + ".cluster.com"
-
-		crd := apiextensions.CustomResourceDefinition{
-			ObjectMeta: metav1.ObjectMeta{
-				Name: crdName,
-			},
-			Spec: apiextensions.CustomResourceDefinitionSpec{
-				Group:   "cluster.com",
-				Version: "v1alpha1",
-				Names: apiextensions.CustomResourceDefinitionNames{
-					Plural:   crdPlural,
-					Singular: crdPlural,
-					Kind:     crdPlural,
-					ListKind: "list" + crdPlural,
-				},
-				Scope: "Namespaced",
-			},
-		}
-
-		crd2 := apiextensions.CustomResourceDefinition{
-			ObjectMeta: metav1.ObjectMeta{
-				Name: crdName2,
-			},
-			Spec: apiextensions.CustomResourceDefinitionSpec{
-				Group:   "cluster.com",
-				Version: "v1alpha1",
-				Names: apiextensions.CustomResourceDefinitionNames{
-					Plural:   crdPlural2,
-					Singular: crdPlural2,
-					Kind:     crdPlural2,
-					ListKind: "list" + crdPlural2,
-				},
-				Scope: "Namespaced",
-			},
-		}
-
-		// Create CSV
-		packageName1 := genName("apackage")
-		packageName2 := genName("bpackage")
-
-		namedStrategy := newNginxInstallStrategy((genName("dep")), permissions, nil)
-		depNamedStrategy := newNginxInstallStrategy((genName("dep")), permissions, nil)
-		depNamedStrategy2 := newNginxInstallStrategy((genName("dep")), permissions, nil)
-		// csvA requires CRD1 and CRD2
-		csvA := newCSV("nginx-a", testNamespace, "", semver.MustParse("0.1.0"), nil, []apiextensions.CustomResourceDefinition{crd, crd2}, namedStrategy)
-		// csvABC provides CRD1 and CRD2 in the same catalogsource with csvA (apackage)
-		// also in the same package with csvA but different channel
-		csvABC := newCSV("nginx-a-bc", testNamespace, "", semver.MustParse("0.1.0"), []apiextensions.CustomResourceDefinition{crd, crd2}, nil, namedStrategy)
-		// csvB provides CRD1 in the same catalogsource with csvA (apackage)
-		csvB := newCSV("nginx-b-dep", testNamespace, "", semver.MustParse("0.1.0"), []apiextensions.CustomResourceDefinition{crd}, nil, depNamedStrategy)
-		// csvC provides CRD2 in the different catalogsource with csvA (apackage)
-		csvC := newCSV("nginx-c-dep", testNamespace, "", semver.MustParse("0.1.0"), []apiextensions.CustomResourceDefinition{crd2}, nil, depNamedStrategy2)
-
-		// Create PackageManifests 1
-		// Contain csvA, ABC and B
-		manifests := []registry.PackageManifest{
-			{
-				PackageName: packageName1,
-				Channels: []registry.PackageChannel{
-					{Name: stableChannel, CurrentCSVName: csvA.GetName()},
-					{Name: alphaChannel, CurrentCSVName: csvABC.GetName()},
-				},
-				DefaultChannelName: stableChannel,
-			},
-			{
-				PackageName: packageName2,
-				Channels: []registry.PackageChannel{
-					{Name: stableChannel, CurrentCSVName: csvB.GetName()},
-				},
-				DefaultChannelName: stableChannel,
-			},
-		}
-
-		// Create PackageManifests 2
-		// Contain csvC
-		manifests2 := []registry.PackageManifest{
-			{
-				PackageName: packageName2,
-				Channels: []registry.PackageChannel{
-					{Name: stableChannel, CurrentCSVName: csvC.GetName()},
-				},
-				DefaultChannelName: stableChannel,
-			},
-		}
-
-		catalogSourceName := genName("catsrc")
-		catsrc, cleanup := createInternalCatalogSource(kubeClient, crClient, catalogSourceName, testNamespace, manifests, []apiextensions.CustomResourceDefinition{crd, crd2}, []v1alpha1.ClusterServiceVersion{csvA, csvABC, csvB})
-		defer cleanup()
-
-		// Ensure that the catalog source is resolved before we create a subscription.
-		_, err := fetchCatalogSourceOnStatus(crClient, catsrc.GetName(), testNamespace, catalogSourceRegistryPodSynced)
-		require.NoError(GinkgoT(), err)
-
-		subscriptionSpec := &v1alpha1.SubscriptionSpec{
-			CatalogSource:          catsrc.GetName(),
-			CatalogSourceNamespace: catsrc.GetNamespace(),
-			Package:                packageName1,
-			Channel:                stableChannel,
-			StartingCSV:            csvA.GetName(),
-			InstallPlanApproval:    v1alpha1.ApprovalAutomatic,
-		}
-
-		catalogSourceName2 := genName("catsrc")
-		catsrc2, cleanup2 := createInternalCatalogSource(kubeClient, crClient, catalogSourceName2, testNamespace, manifests2, []apiextensions.CustomResourceDefinition{crd2}, []v1alpha1.ClusterServiceVersion{csvC})
-		defer cleanup2()
-
-		// Ensure that the catalog source is resolved before we create a subscription.
-		_, err = fetchCatalogSourceOnStatus(crClient, catsrc2.GetName(), testNamespace, catalogSourceRegistryPodSynced)
-		require.NoError(GinkgoT(), err)
-
-		// Create a subscription that has a dependency
-		subscriptionName := genName("sub-")
-		cleanupSubscription := createSubscriptionForCatalogWithSpec(GinkgoT(), crClient, testNamespace, subscriptionName, subscriptionSpec)
-		defer cleanupSubscription()
-
-		subscription, err := fetchSubscription(crClient, testNamespace, subscriptionName, subscriptionStateAtLatestChecker)
-		require.NoError(GinkgoT(), err)
-		require.NotNil(GinkgoT(), subscription)
-
-		// Check that a single catalog source was used to resolve the InstallPlan
-		_, err = fetchInstallPlan(GinkgoT(), crClient, subscription.Status.InstallPlanRef.Name, buildInstallPlanPhaseCheckFunc(v1alpha1.InstallPlanPhaseComplete))
-		require.NoError(GinkgoT(), err)
-		// Fetch CSVs A, B and C
-		_, err = fetchCSV(GinkgoT(), crClient, csvB.Name, testNamespace, csvSucceededChecker)
-		require.NoError(GinkgoT(), err)
-		_, err = fetchCSV(GinkgoT(), crClient, csvC.Name, testNamespace, csvSucceededChecker)
-		require.NoError(GinkgoT(), err)
-		_, err = fetchCSV(GinkgoT(), crClient, csvA.Name, testNamespace, csvSucceededChecker)
-		require.NoError(GinkgoT(), err)
-		// Ensure csvABC is not installed
-		_, err = crClient.OperatorsV1alpha1().ClusterServiceVersions(testNamespace).Get(context.TODO(), csvABC.Name, metav1.GetOptions{})
-		require.Error(GinkgoT(), err)
-	})
 })
 
 const (
diff --git a/vendor/github.com/sirupsen/logrus/hooks/test/test.go b/vendor/github.com/sirupsen/logrus/hooks/test/test.go
new file mode 100644
index 000000000..234a17dfa
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/hooks/test/test.go
@@ -0,0 +1,92 @@
+// The Test package is used for testing logrus. It is here for backwards
+// compatibility from when logrus' organization was upper-case. Please use
+// lower-case logrus and the `null` package instead of this one.
+package test
+
+import (
+	"io/ioutil"
+	"sync"
+
+	"github.com/sirupsen/logrus"
+)
+
+// Hook is a hook designed for dealing with logs in test scenarios.
+type Hook struct {
+	// Entries is an array of all entries that have been received by this hook.
+	// For safe access, use the AllEntries() method, rather than reading this
+	// value directly.
+	Entries []logrus.Entry
+	mu      sync.RWMutex
+}
+
+// NewGlobal installs a test hook for the global logger.
+func NewGlobal() *Hook {
+
+	hook := new(Hook)
+	logrus.AddHook(hook)
+
+	return hook
+
+}
+
+// NewLocal installs a test hook for a given local logger.
+func NewLocal(logger *logrus.Logger) *Hook {
+
+	hook := new(Hook)
+	logger.Hooks.Add(hook)
+
+	return hook
+
+}
+
+// NewNullLogger creates a discarding logger and installs the test hook.
+func NewNullLogger() (*logrus.Logger, *Hook) {
+
+	logger := logrus.New()
+	logger.Out = ioutil.Discard
+
+	return logger, NewLocal(logger)
+
+}
+
+func (t *Hook) Fire(e *logrus.Entry) error {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	t.Entries = append(t.Entries, *e)
+	return nil
+}
+
+func (t *Hook) Levels() []logrus.Level {
+	return logrus.AllLevels
+}
+
+// LastEntry returns the last entry that was logged or nil.
+func (t *Hook) LastEntry() *logrus.Entry {
+	t.mu.RLock()
+	defer t.mu.RUnlock()
+	i := len(t.Entries) - 1
+	if i < 0 {
+		return nil
+	}
+	return &t.Entries[i]
+}
+
+// AllEntries returns all entries that were logged.
+func (t *Hook) AllEntries() []*logrus.Entry {
+	t.mu.RLock()
+	defer t.mu.RUnlock()
+	// Make a copy so the returned value won't race with future log requests
+	entries := make([]*logrus.Entry, len(t.Entries))
+	for i := 0; i < len(t.Entries); i++ {
+		// Make a copy, for safety
+		entries[i] = &t.Entries[i]
+	}
+	return entries
+}
+
+// Reset removes all Entries from this test hook.
+func (t *Hook) Reset() {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	t.Entries = make([]logrus.Entry, 0)
+}