✨ Add scaffolding for the webhook test suite

pkg/plugin/v3/api.go

@@ -43,6 +43,10 @@ import (
 // TODO: remove this when a better solution for using addons is implemented.
 const KbDeclarativePatternVersion = "v0.0.0-20200522144838-848d48e5b073"
 
+// AddonPlugin is the name of the plugin for addons.
+// TODO: the addon should be a plugin. More info: #1543
+const AddonPlugin = "addon"
+
 // DefaultMainPath is default file path of main.go
 const DefaultMainPath = "main.go"
 
@@ -190,7 +194,7 @@ func (p *createAPIPlugin) GetScaffolder() (scaffold.Scaffolder, error) {
 	switch strings.ToLower(p.pattern) {
 	case "":
 		// Default pattern
-	case "addon":
+	case AddonPlugin:
 		plugins = append(plugins, &addon.Plugin{})
 	default:
 		return nil, fmt.Errorf("unknown pattern %q", p.pattern)
@@ -206,7 +210,7 @@ func (p *createAPIPlugin) PostScaffold() error {
 	switch strings.ToLower(p.pattern) {
 	case "":
 		// Default pattern
-	case "addon":
+	case AddonPlugin:
 		// Ensure that we are pinning sigs.k8s.io/kubebuilder-declarative-pattern version
 		// TODO: either find a better way to inject this version (ex. tools.go).
 		err := util.RunCmd("Get kubebuilder-declarative-pattern dependency", "go", "get",

pkg/plugin/v3/scaffolds/internal/templates/config/api/webhook_suitetest.go

@@ -0,0 +1,225 @@
+package api
+
+import (
+	"fmt"
+	"path/filepath"
+
+	"sigs.k8s.io/kubebuilder/pkg/model/file"
+)
+
+var _ file.Template = &WebhookSuite{}
+var _ file.Inserter = &WebhookSuite{}
+
+// WebhookSuite scaffolds the webhook_suite.go file to setup the webhook test
+type WebhookSuite struct {
+	file.TemplateMixin
+	file.MultiGroupMixin
+	file.BoilerplateMixin
+	file.ResourceMixin
+
+	// BaseDirectoryRelativePath define the Path for the base directory when it is multigroup
+	BaseDirectoryRelativePath string
+}
+
+// SetTemplateDefaults implements file.Template
+func (f *WebhookSuite) SetTemplateDefaults() error {
+	if f.Path == "" {
+		if f.MultiGroup {
+			if f.Resource.Group != "" {
+				f.Path = filepath.Join("apis", "%[group]", "%[version]", "webhook_suite_test.go")
+			} else {
+				f.Path = filepath.Join("apis", "%[version]", "webhook_suite_test.go")
+			}
+		} else {
+			f.Path = filepath.Join("api", "%[version]", "webhook_suite_test.go")
+		}
+	}
+	f.Path = f.Resource.Replacer().Replace(f.Path)
+
+	f.TemplateBody = fmt.Sprintf(webhookTestSuiteTemplate,
+		file.NewMarkerFor(f.Path, importMarker),
+		file.NewMarkerFor(f.Path, addSchemeMarker),
+		file.NewMarkerFor(f.Path, addWebhookManagerMarker),
+		"%s",
+		"%d",
+	)
+
+	// If is multigroup the path needs to be ../../.. since it has the group dir.
+	f.BaseDirectoryRelativePath = `"..", ".."`
+	if f.MultiGroup && f.Resource.Group != "" {
+		f.BaseDirectoryRelativePath = `"..", "..",".."`
+	}
+
+	return nil
+}
+
+const (
+	// TODO: admission webhook versions should be based on the input of the user. For More Info #1664
+	admissionImportAlias    = "admissionv1beta1"
+	admissionPath           = "k8s.io/api/admission/v1beta1"
+	importMarker            = "imports"
+	addWebhookManagerMarker = "webhook"
+	addSchemeMarker         = "scheme"
+)
+
+// GetMarkers implements file.Inserter
+func (f *WebhookSuite) GetMarkers() []file.Marker {
+	return []file.Marker{
+		file.NewMarkerFor(f.Path, importMarker),
+		file.NewMarkerFor(f.Path, addSchemeMarker),
+		file.NewMarkerFor(f.Path, addWebhookManagerMarker),
+	}
+}
+
+const (
+	apiImportCodeFragment = `%s "%s"
+`
+	addschemeCodeFragment = `err = %s.AddToScheme(scheme	)
+Expect(err).NotTo(HaveOccurred())
+
+`
+	addWebhookManagerCodeFragment = `err = (&%s{}).SetupWebhookWithManager(mgr)
+Expect(err).NotTo(HaveOccurred())
+
+`
+)
+
+// GetCodeFragments implements file.Inserter
+func (f *WebhookSuite) GetCodeFragments() file.CodeFragmentsMap {
+	fragments := make(file.CodeFragmentsMap, 3)
+
+	// Generate import code fragments
+	imports := make([]string, 0)
+	imports = append(imports, fmt.Sprintf(apiImportCodeFragment, admissionImportAlias, admissionPath))
+
+	// Generate add scheme code fragments
+	addScheme := make([]string, 0)
+	addScheme = append(addScheme, fmt.Sprintf(addschemeCodeFragment, admissionImportAlias))
+
+	// Generate add webhookManager code fragments
+	addWebhookManager := make([]string, 0)
+	addWebhookManager = append(addWebhookManager, fmt.Sprintf(addWebhookManagerCodeFragment, f.Resource.Kind))
+
+	// Only store code fragments in the map if the slices are non-empty
+	if len(addWebhookManager) != 0 {
+		fragments[file.NewMarkerFor(f.Path, addWebhookManagerMarker)] = addWebhookManager
+	}
+	if len(imports) != 0 {
+		fragments[file.NewMarkerFor(f.Path, importMarker)] = imports
+	}
+	if len(addScheme) != 0 {
+		fragments[file.NewMarkerFor(f.Path, addSchemeMarker)] = addScheme
+	}
+
+	return fragments
+}
+
+const (
+	webhookTestSuiteTemplate = `
+package {{ .Resource.Version }}
+
+import (
+	"path/filepath"
+	"testing"
+	"fmt"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	%s
+	"k8s.io/client-go/kubernetes/scheme"
+	"k8s.io/client-go/rest"
+	"k8s.io/apimachinery/pkg/runtime"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/envtest"
+	"sigs.k8s.io/controller-runtime/pkg/envtest/printer"
+	logf "sigs.k8s.io/controller-runtime/pkg/log"
+	"sigs.k8s.io/controller-runtime/pkg/log/zap"
+)
+
+// These tests use Ginkgo (BDD-style Go testing framework). Refer to
+// http://onsi.github.io/ginkgo/ to learn more about Ginkgo.
+
+var cfg *rest.Config
+var k8sClient client.Client
+var testEnv *envtest.Environment
+var stopCh = make(chan struct{})
+
+func TestAPIs(t *testing.T) {
+	RegisterFailHandler(Fail)
+
+	RunSpecsWithDefaultAndCustomReporters(t,
+	"Webhook Suite",
+	[]Reporter{printer.NewlineReporter{}})
+}
+
+var _ = BeforeSuite(func(done Done) {
+	logf.SetLogger(zap.New(zap.WriteTo(GinkgoWriter), zap.UseDevMode(true)))
+
+	By("bootstrapping test environment")
+	testEnv = &envtest.Environment{
+		CRDDirectoryPaths: []string{filepath.Join({{ .BaseDirectoryRelativePath }}, "config", "crd", "bases")},
+		WebhookInstallOptions: envtest.WebhookInstallOptions{
+			DirectoryPaths: []string{filepath.Join({{ .BaseDirectoryRelativePath }}, "config", "webhook")},
+		},
+	}
+
+	var err error
+	cfg, err = testEnv.Start()
+	Expect(err).NotTo(HaveOccurred())
+	Expect(cfg).NotTo(BeNil())
+
+	scheme := runtime.NewScheme()
+	err = AddToScheme(scheme)
+	Expect(err).NotTo(HaveOccurred())
+
+	%s
+	
+	k8sClient, err = client.New(cfg, client.Options{Scheme: scheme})
+	Expect(err).NotTo(HaveOccurred())
+	Expect(k8sClient).NotTo(BeNil())
+
+	// start webhook server using Manager
+	webhookInstallOptions := &testEnv.WebhookInstallOptions
+	mgr, err := ctrl.NewManager(cfg, ctrl.Options{
+		Scheme:             scheme,
+		Host:               webhookInstallOptions.LocalServingHost,
+		Port:               webhookInstallOptions.LocalServingPort,
+		CertDir:            webhookInstallOptions.LocalServingCertDir,
+		LeaderElection:     false,
+		MetricsBindAddress: "0",
+	})
+	Expect(err).NotTo(HaveOccurred())
+
+	%s
+
+	go func() {
+		err = mgr.Start(stopCh)
+		if err != nil {
+			Expect(err).NotTo(HaveOccurred())
+		}
+	}()
+
+	// wait for the webhook server to get ready
+	dialer := &net.Dialer{Timeout: time.Second}
+	addrPort := fmt.Sprintf("%s:%s", webhookInstallOptions.LocalServingHost, webhookInstallOptions.LocalServingPort)
+	Eventually(func() error {
+		conn, err := tls.DialWithDialer(dialer, "tcp", addrPort, &tls.Config{InsecureSkipVerify: true})
+		if err != nil {
+			return err
+		}
+		conn.Close()
+		return nil
+	}).Should(Succeed())
+
+	close(done)
+}, 60)
+
+var _ = AfterSuite(func() {
+	close(stopCh)
+	By("tearing down the test environment")
+	err := testEnv.Stop()
+	Expect(err).NotTo(HaveOccurred())
+})
+`
+)

pkg/plugin/v3/scaffolds/webhook.go

@@ -34,7 +34,6 @@ type webhookScaffolder struct {
 	config      *config.Config
 	boilerplate string
 	resource    *resource.Resource
-
 	// Webhook type options.
 	defaulting, validation, conversion bool
 }
@@ -86,5 +85,15 @@ You need to implement the conversion.Hub and conversion.Convertible interfaces f
 		return err
 	}
 
+	// TODO: Add test suite for conversion webhook after #1664 has been merged & conversion tests supported in envtest.
+	if s.defaulting || s.validation {
+		if err := machinery.NewScaffold().Execute(
+			s.newUniverse(),
+			&api.WebhookSuite{},
+		); err != nil {
+			return err
+		}
+	}
+
 	return nil
 }

pkg/plugin/v3/webhook.go

@@ -114,7 +114,8 @@ func (p *createWebhookPlugin) GetScaffolder() (scaffold.Scaffolder, error) {
 
 	// Create the actual resource from the resource options
 	res := p.resource.NewResource(p.config, false)
-	return scaffolds.NewWebhookScaffolder(p.config, string(bp), res, p.defaulting, p.validation, p.conversion), nil
+	return scaffolds.NewWebhookScaffolder(p.config, string(bp), res, p.defaulting, p.validation, p.conversion),
+		nil
 }
 
 func (p *createWebhookPlugin) PostScaffold() error {