deepcopy_integration_test: Be more integrated

Author: LukeShu

pkg/deepcopy/deepcopy_integration_test.go

@@ -17,34 +17,51 @@ limitations under the License.
 package deepcopy_test
 
 import (
+	"io"
 	"io/ioutil"
 	"os"
+	"sort"
 
 	"github.com/google/go-cmp/cmp"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
-	"golang.org/x/tools/go/packages"
 
 	"sigs.k8s.io/controller-tools/pkg/deepcopy"
+	"sigs.k8s.io/controller-tools/pkg/genall"
 	"sigs.k8s.io/controller-tools/pkg/loader"
 	"sigs.k8s.io/controller-tools/pkg/markers"
 )
 
-func packageErrors(pkg *loader.Package, filterKinds ...packages.ErrorKind) error {
-	toSkip := make(map[packages.ErrorKind]struct{})
-	for _, errKind := range filterKinds {
-		toSkip[errKind] = struct{}{}
+type outputToMap map[string]*outputFile
+
+// Open implements genall.OutputRule.
+func (m outputToMap) Open(_ *loader.Package, path string) (io.WriteCloser, error) {
+	if _, ok := m[path]; !ok {
+		m[path] = &outputFile{}
 	}
-	var outErr error
-	packages.Visit([]*packages.Package{pkg.Package}, nil, func(pkgRaw *packages.Package) {
-		for _, err := range pkgRaw.Errors {
-			if _, skip := toSkip[err.Kind]; skip {
-				continue
-			}
-			outErr = err
-		}
-	})
-	return outErr
+	return m[path], nil
+}
+
+func (m outputToMap) fileList() []string {
+	ret := make([]string, 0, len(m))
+	for path := range m {
+		ret = append(ret, path)
+	}
+	sort.Strings(ret)
+	return ret
+}
+
+type outputFile struct {
+	contents []byte
+}
+
+func (o *outputFile) Write(p []byte) (int, error) {
+	o.contents = append(o.contents, p...)
+	return len(p), nil
+}
+
+func (o *outputFile) Close() error {
+	return nil
 }
 
 var _ = Describe("CRD Generation From Parsing to CustomResourceDefinition", func() {
@@ -55,28 +72,23 @@ var _ = Describe("CRD Generation From Parsing to CustomResourceDefinition", func
 		Expect(os.Chdir("./testdata")).To(Succeed()) // go modules are directory-sensitive
 		defer func() { Expect(os.Chdir(cwd)).To(Succeed()) }()
 
-		By("loading the roots")
-		pkgs, err := loader.LoadRoots(".")
-		Expect(err).NotTo(HaveOccurred())
-		Expect(pkgs).To(HaveLen(1))
-		cronJobPkg := pkgs[0]
+		output := make(outputToMap)
 
-		By("setting up the generation context")
-		collector := &markers.Collector{Registry: &markers.Registry{}}
-		Expect(deepcopy.Generator{}.RegisterMarkers(collector.Registry)).To(Succeed())
-		checker := &loader.TypeChecker{}
-		ctx := &deepcopy.ObjectGenCtx{
-			Collector: collector,
-			Checker:   checker,
-		}
-
-		By("requesting that types be generated")
-		outContents := ctx.GenerateForPackage(cronJobPkg)
+		By("initializing the runtime")
+		optionsRegistry := &markers.Registry{}
+		Expect(optionsRegistry.Register(markers.Must(markers.MakeDefinition("object", markers.DescribesPackage, deepcopy.Generator{})))).To(Succeed())
+		rt, err := genall.FromOptions(optionsRegistry, []string{"object"})
+		Expect(err).NotTo(HaveOccurred())
+		rt.OutputRules = genall.OutputRules{Default: output}
 
-		By("checking that no errors occurred along the way (expect for type errors)")
-		Expect(packageErrors(cronJobPkg, packages.TypeError)).NotTo(HaveOccurred())
+		By("running the generator and checking for errors")
+		hadErrs := rt.Run()
 
 		By("checking that we got output contents")
+		Expect(output.fileList()).To(ContainElement("zz_generated.deepcopy.go")) // Don't use HaveKey--the output is too verbose to be usable
+		outFile := output["zz_generated.deepcopy.go"]
+		Expect(outFile).NotTo(BeNil())
+		outContents := outFile.contents
 		Expect(outContents).NotTo(BeNil())
 
 		By("loading the desired code")
@@ -85,5 +97,8 @@ var _ = Describe("CRD Generation From Parsing to CustomResourceDefinition", func
 
 		By("comparing the two")
 		Expect(string(outContents)).To(Equal(string(expectedFile)), "generated code not as expected, check pkg/deepcopy/testdata/README.md for more details.\n\nDiff:\n\n%s", cmp.Diff(outContents, expectedFile))
+
+		By("checking for errors")
+		Expect(hadErrs).To(BeFalse())
 	})
 })

pkg/deepcopy/gen.go

@@ -144,7 +144,7 @@ func (d Generator) Generate(ctx *genall.GenerationContext) error {
 	}
 
 	for _, root := range ctx.Roots {
-		outContents := objGenCtx.GenerateForPackage(root)
+		outContents := objGenCtx.generateForPackage(root)
 		if outContents == nil {
 			continue
 		}
@@ -186,10 +186,10 @@ import (
 
 }
 
-// GenerateForPackage generates DeepCopy and runtime.Object implementations for
+// generateForPackage generates DeepCopy and runtime.Object implementations for
 // types in the given package, writing the formatted result to given writer.
 // May return nil if source could not be generated.
-func (ctx *ObjectGenCtx) GenerateForPackage(root *loader.Package) []byte {
+func (ctx *ObjectGenCtx) generateForPackage(root *loader.Package) []byte {
 	allTypes, err := enabledOnPackage(ctx.Collector, root)
 	if err != nil {
 		root.AddError(err)