diff --git a/test/integration/packagemanifests_test.go b/test/integration/packagemanifests_test.go
index a474fc7fa02..a706b35b5b9 100644
--- a/test/integration/packagemanifests_test.go
+++ b/test/integration/packagemanifests_test.go
@@ -19,7 +19,6 @@ import (
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
-	"github.com/operator-framework/api/pkg/operators/v1alpha1"
 )
 
 var _ = Describe("run packagemanifests", func() {
@@ -29,41 +28,27 @@ var _ = Describe("run packagemanifests", func() {
 		output string
 	)
 
-	runPackageManifests := runPackageManifestsFor(&tc)
-	cleanup := cleanupFor(&tc)
-	isBundle := false
-	readCSV, writeCSV := readCSVFor(&tc, isBundle), writeCSVFor(&tc, isBundle)
-
 	AfterEach(func() {
 		By("cleaning up")
-		_, err = cleanup()
+		_, err = cleanup(&tc)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
 	It("should handle existing operator deployments correctly", func() {
-		output, err = cleanup()
+		output, err = cleanup(&tc)
 		Expect(err).NotTo(HaveOccurred())
 		Expect(output).To(ContainSubstring(`package \"memcached-operator\" not found`))
-		Expect(runPackageManifests("--version", "0.0.1")).To(Succeed())
-		Expect(runPackageManifests("--version", "0.0.1")).NotTo(Succeed())
-		_, err = cleanup()
+		Expect(runPackageManifests(&tc, "--version", "0.0.1")).To(Succeed())
+		Expect(runPackageManifests(&tc, "--version", "0.0.1")).NotTo(Succeed())
+		_, err = cleanup(&tc)
 		Expect(err).NotTo(HaveOccurred())
-		output, err = cleanup()
+		output, err = cleanup(&tc)
 		Expect(err).NotTo(HaveOccurred())
 		Expect(output).To(ContainSubstring(`package \"memcached-operator\" not found`))
 	})
 
 	It("should succeed with a single operator version in OwnNamespace mode", func() {
-		csv, err := readCSV("0.0.1")
-		Expect(err).NotTo(HaveOccurred())
-		for i, mode := range csv.Spec.InstallModes {
-			if mode.Type == v1alpha1.InstallModeTypeOwnNamespace {
-				csv.Spec.InstallModes[i].Supported = true
-				break
-			}
-		}
-		Expect(writeCSV(csv, "0.0.1")).To(Succeed())
-		Expect(runPackageManifests("--install-mode", "OwnNamespace", "--version", "0.0.1")).To(Succeed())
+		Expect(runPackageManifests(&tc, "--install-mode", "OwnNamespace", "--version", "0.0.1")).To(Succeed())
 	})
 
 	It("should successfully deploy the second of two operator versions", func() {
@@ -82,6 +67,6 @@ var _ = Describe("run packagemanifests", func() {
 			}
 			Expect(tc.Make(makeArgs...)).To(Succeed())
 		}
-		Expect(runPackageManifests("--version", versions[len(versions)-1])).To(Succeed())
+		Expect(runPackageManifests(&tc, "--version", versions[len(versions)-1])).To(Succeed())
 	})
 })
diff --git a/test/integration/suite_test.go b/test/integration/suite_test.go
index 7c609eb1128..08130c20dbe 100644
--- a/test/integration/suite_test.go
+++ b/test/integration/suite_test.go
@@ -84,8 +84,14 @@ var _ = BeforeSuite(func() {
 		Expect(tc.LoadImageToKindCluster()).To(Succeed())
 	}
 
-	By("generating the operator package manifests")
+	By("generating the operator package manifests and enabling all InstallModes")
 	Expect(tc.Make("packagemanifests", "IMG="+tc.ImageName)).To(Succeed())
+	csv, err := readCSV(&tc, "0.0.1", false)
+	Expect(err).NotTo(HaveOccurred())
+	for i := range csv.Spec.InstallModes {
+		csv.Spec.InstallModes[i].Supported = true
+	}
+	Expect(writeCSV(&tc, "0.0.1", csv, false)).To(Succeed())
 
 	// TODO(estroz): enable when bundles can be tested locally.
 	//
@@ -122,60 +128,52 @@ func warn(output string, err error) {
 	}
 }
 
-func runPackageManifestsFor(tc *testutils.TestContext) func(...string) error {
-	return func(args ...string) error {
-		allArgs := []string{"run", "packagemanifests", "--timeout", "4m", "--namespace", tc.Kubectl.Namespace}
-		output, err := tc.Run(exec.Command(tc.BinaryName, append(allArgs, args...)...))
-		if err == nil {
-			fmt.Fprintln(GinkgoWriter, string(output))
-		}
-		return err
+func runPackageManifests(tc *testutils.TestContext, args ...string) error {
+	allArgs := []string{"run", "packagemanifests", "--timeout", "4m", "--namespace", tc.Kubectl.Namespace}
+	output, err := tc.Run(exec.Command(tc.BinaryName, append(allArgs, args...)...))
+	if err == nil {
+		fmt.Fprintln(GinkgoWriter, string(output))
 	}
+	return err
 }
 
-func cleanupFor(tc *testutils.TestContext) func() (string, error) {
-	return func() (string, error) {
-		allArgs := []string{"cleanup", tc.ProjectName, "--timeout", "4m", "--namespace", tc.Kubectl.Namespace}
-		output, err := tc.Run(exec.Command(tc.BinaryName, allArgs...))
-		if err == nil {
-			fmt.Fprintln(GinkgoWriter, string(output))
-		}
-		return string(output), err
+func cleanup(tc *testutils.TestContext) (string, error) {
+	allArgs := []string{"cleanup", tc.ProjectName, "--timeout", "4m", "--namespace", tc.Kubectl.Namespace}
+	output, err := tc.Run(exec.Command(tc.BinaryName, allArgs...))
+	if err == nil {
+		fmt.Fprintln(GinkgoWriter, string(output))
 	}
+	return string(output), err
 }
 
-func readCSVFor(tc *testutils.TestContext, isBundle bool) func(string) (*v1alpha1.ClusterServiceVersion, error) {
-	return func(version string) (*v1alpha1.ClusterServiceVersion, error) {
-		b, err := ioutil.ReadFile(csvPath(tc, version, isBundle))
-		if err != nil {
-			return nil, err
-		}
-		csv := &v1alpha1.ClusterServiceVersion{}
-		if err := yaml.Unmarshal(b, csv); err != nil {
-			return nil, err
-		}
-		return csv, nil
+func readCSV(tc *testutils.TestContext, version string, isBundle bool) (*v1alpha1.ClusterServiceVersion, error) {
+	b, err := ioutil.ReadFile(csvPath(tc, version, isBundle))
+	if err != nil {
+		return nil, err
 	}
+	csv := &v1alpha1.ClusterServiceVersion{}
+	if err := yaml.Unmarshal(b, csv); err != nil {
+		return nil, err
+	}
+	return csv, nil
 }
 
-func writeCSVFor(tc *testutils.TestContext, isBundle bool) func(*v1alpha1.ClusterServiceVersion, string) error {
-	return func(csv *v1alpha1.ClusterServiceVersion, version string) error {
-		b, err := yaml.Marshal(csv)
-		if err != nil {
-			return err
-		}
-		f, err := os.OpenFile(csvPath(tc, version, isBundle), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
-		if err != nil {
-			return err
-		}
-		if _, err := f.Write(b); err != nil {
-			return err
-		}
-		if err := f.Sync(); err != nil {
-			return err
-		}
-		return f.Close()
+func writeCSV(tc *testutils.TestContext, version string, csv *v1alpha1.ClusterServiceVersion, isBundle bool) error {
+	b, err := yaml.Marshal(csv)
+	if err != nil {
+		return err
+	}
+	f, err := os.OpenFile(csvPath(tc, version, isBundle), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
+	if err != nil {
+		return err
+	}
+	if _, err := f.Write(b); err != nil {
+		return err
+	}
+	if err := f.Sync(); err != nil {
+		return err
 	}
+	return f.Close()
 }
 
 func csvPath(tc *testutils.TestContext, version string, isBundle bool) string {