start apiserver and proxy for e2e tests

e2e/e2e_test.go

@@ -3,20 +3,151 @@
 package e2e
 
 import (
+	"bytes"
+	"context"
+	"encoding/gob"
+	"fmt"
+	"net"
+	"os"
+	"runtime"
 	"testing"
 	"time"
 
+	"github.com/go-logr/zapr"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
+	"github.com/spf13/afero"
+	"go.uber.org/zap"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
+
+	"sigs.k8s.io/controller-runtime/pkg/envtest"
+	"sigs.k8s.io/controller-runtime/tools/setup-envtest/env"
+	"sigs.k8s.io/controller-runtime/tools/setup-envtest/remote"
+	"sigs.k8s.io/controller-runtime/tools/setup-envtest/store"
+	"sigs.k8s.io/controller-runtime/tools/setup-envtest/versions"
+	"sigs.k8s.io/controller-runtime/tools/setup-envtest/workflows"
+
+	"github.com/authzed/spicedb-kubeapi-proxy/pkg/proxy"
+)
+
+var (
+	// adminUser is configured for the un-proxied apiserver
+	adminUser *envtest.AuthenticatedUser
+	testEnv   *envtest.Environment
 )
 
-func init() {
+func TestEndToEnd(t *testing.T) {
+	RunSpecs(t, "proxy tests")
+}
+
+var _ = SynchronizedBeforeSuite(func() []byte {
+	RegisterFailHandler(Fail)
 	SetDefaultEventuallyTimeout(1 * time.Minute)
 	SetDefaultEventuallyPollingInterval(1 * time.Second)
 	SetDefaultConsistentlyDuration(5 * time.Second)
 	SetDefaultConsistentlyPollingInterval(100 * time.Millisecond)
+
+	// this runs only once, no matter how many processes are running tests
+	testEnv = &envtest.Environment{
+		ControlPlaneStopTimeout: 3 * time.Minute,
+	}
+
+	ConfigureApiserver()
+
+	config, err := testEnv.Start()
+	Expect(err).To(Succeed())
+	DeferCleanup(testEnv.Stop)
+	DisableClientRateLimits(config)
+
+	var buf bytes.Buffer
+	enc := gob.NewEncoder(&buf)
+	Expect(enc.Encode(config)).To(Succeed())
+	return buf.Bytes()
+}, func(ctx context.Context, rc []byte) {
+	dec := gob.NewDecoder(bytes.NewReader(rc))
+	var config rest.Config
+	Expect(dec.Decode(&config)).To(Succeed())
+
+	user, err := testEnv.AddUser(envtest.User{Name: "admin"}, &config)
+	Expect(err).To(Succeed())
+	adminUser = user
+
+	kubecfgBytes, err := adminUser.KubeConfig()
+	Expect(err).To(Succeed())
+	backendCfg, err := clientcmd.Load(kubecfgBytes)
+	Expect(err).To(Succeed())
+
+	opts := proxy.NewOptions()
+	opts.BackendConfig = backendCfg
+	opts.SecureServing.BindPort, err = GetFreePort("localhost")
+	Expect(err).To(Succeed())
+	Expect(opts.Complete(ctx)).To(Succeed())
+	proxySrv, err := proxy.NewServer(ctx, *opts)
+	Expect(err).To(Succeed())
+	Expect(proxySrv.Complete(ctx)).To(Succeed())
+	go func() {
+		defer GinkgoRecover()
+		Expect(proxySrv.Run(ctx))
+	}()
+})
+
+func ConfigureApiserver() {
+	logCfg := zap.NewDevelopmentConfig()
+	logCfg.Level = zap.NewAtomicLevelAt(zap.InfoLevel)
+	zapLog, err := logCfg.Build()
+	Expect(err).To(Succeed())
+	log := zapr.NewLogger(zapLog)
+
+	e := &env.Env{
+		Log: log,
+		Client: &remote.Client{
+			Log:    log,
+			Bucket: "kubebuilder-tools",
+			Server: "storage.googleapis.com",
+		},
+		Version: versions.Spec{
+			Selector:    versions.TildeSelector{},
+			CheckLatest: false,
+		},
+		VerifySum:     true,
+		ForceDownload: false,
+		Platform: versions.PlatformItem{
+			Platform: versions.Platform{
+				OS:   runtime.GOOS,
+				Arch: runtime.GOARCH,
+			},
+		},
+		FS:    afero.Afero{Fs: afero.NewOsFs()},
+		Store: store.NewAt("../testbin"),
+		Out:   os.Stdout,
+	}
+	e.Version, err = versions.FromExpr("~1.27.0")
+	Expect(err).To(Succeed())
+
+	workflows.Use{
+		UseEnv:      true,
+		PrintFormat: env.PrintOverview,
+		AssetsPath:  "../testbin",
+	}.Do(e)
+
+	Expect(os.Setenv("KUBEBUILDER_ASSETS", fmt.Sprintf("../testbin/k8s/%s-%s-%s", e.Version.AsConcrete(), e.Platform.OS, e.Platform.Arch))).To(Succeed())
+	DeferCleanup(os.Unsetenv, "KUBEBUILDER_ASSETS")
 }
 
-func TestEndToEnd(t *testing.T) {
-	RunSpecs(t, "proxy tests")
+// DisableClientRateLimits removes rate limiting against the apiserver
+func DisableClientRateLimits(restConfig *rest.Config) {
+	restConfig.Burst = 2000
+	restConfig.QPS = -1
+}
+
+// GetFreePort is a helper used to get a free TCP port on the host
+func GetFreePort(listenAddr string) (int, error) {
+	dummyListener, err := net.Listen("tcp", net.JoinHostPort(listenAddr, "0"))
+	if err != nil {
+		return 0, err
+	}
+	defer dummyListener.Close()
+	port := dummyListener.Addr().(*net.TCPAddr).Port
+	return port, nil
 }