Update test from new k8s dependencies

Signed-off-by: JoshVanL <[email protected]>

Author: JoshVanL

test/e2e/suite/suite.go

@@ -23,7 +23,12 @@ var _ = SynchronizedBeforeSuite(func() []byte {
 		log.Fatalf("Error provisioning environment: %v", err)
 	}
 
-	cfg.KubeConfigPath = env.KubeConfigPath()
+	kubeconfig, err := env.KubeConfigPath()
+	if err != nil {
+		log.Fatalf("Failed to determine kubeconfig file: %s", err)
+	}
+
+	cfg.KubeConfigPath = kubeconfig
 	cfg.Kubectl = filepath.Join(env.RootPath(), "bin", "kubectl")
 	cfg.RepoRoot = env.RootPath()
 	cfg.Environment = env

test/environment/dev/dev.go

@@ -32,8 +32,14 @@ func create() {
 	env, err := environment.Create(1, 1)
 	errExit(err)
 
-	fmt.Printf("dev environment created.\nexport KUBECONFIG=%s\n",
-		env.KubeConfigPath())
+	fmt.Printf("dev environment created.\n")
+	kubeconfig, err := env.KubeConfigPath()
+	if err != nil {
+		fmt.Printf("failed to determine kubeconfig path: %s", err)
+		return
+	}
+
+	fmt.Printf("export KUBECONFIG=%s", kubeconfig)
 }
 
 func destroy() {

test/environment/environment.go

@@ -74,7 +74,7 @@ func (e *Environment) KubeClient() *kubernetes.Clientset {
 	return e.kind.KubeClient()
 }
 
-func (e *Environment) KubeConfigPath() string {
+func (e *Environment) KubeConfigPath() (string, error) {
 	return e.kind.KubeConfigPath()
 }
 
@@ -90,7 +90,7 @@ func (e *Environment) Node(name string) (*nodes.Node, error) {
 
 	var node *nodes.Node
 	for _, n := range ns {
-		if n.Name() == name {
+		if n.String() == name {
 			node = &n
 			break
 		}

test/kind/image.go

@@ -2,7 +2,6 @@
 package kind
 
 import (
-	"bytes"
 	"fmt"
 	"io/ioutil"
 	"os"
@@ -61,29 +60,29 @@ func (k *Kind) loadImage(binPath, mainPath, image, dockerfilePath string) error
 		return err
 	}
 
-	nodes, err := k.ctx.ListNodes()
-	if err != nil {
-		return err
-	}
-
-	b, err := ioutil.ReadFile(imageArchive)
-	if err != nil {
-		return err
-	}
-
-	for _, node := range nodes {
-		log.Infof("kind: loading image %q to node %q", image, node.Name())
-		r := bytes.NewBuffer(b)
-		if err := node.LoadImageArchive(r); err != nil {
-			return err
-		}
-
-		err := node.Command("mkdir", "-p", "/tmp/kube-oidc-proxy").Run()
-		if err != nil {
-			return fmt.Errorf("failed to create directory %q: %s",
-				"/tmp/kube-oidc-proxy", err)
-		}
-	}
+	//nodes, err := k.ctx.ListNodes()
+	//if err != nil {
+	//	return err
+	//}
+
+	//b, err := ioutil.ReadFile(imageArchive)
+	//if err != nil {
+	//	return err
+	//}
+
+	//for _, node := range nodes {
+	//	log.Infof("kind: loading image %q to node %q", image, node.Name())
+	//	r := bytes.NewBuffer(b)
+	//	if err := node.LoadImageArchive(r); err != nil {
+	//		return err
+	//	}
+
+	//	err := node.Command("mkdir", "-p", "/tmp/kube-oidc-proxy").Run()
+	//	if err != nil {
+	//		return fmt.Errorf("failed to create directory %q: %s",
+	//			"/tmp/kube-oidc-proxy", err)
+	//	}
+	//}
 
 	return nil
 }

test/kind/kind.go

@@ -13,16 +13,19 @@ import (
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
-	configv1alpha3 "sigs.k8s.io/kind/pkg/apis/config/v1alpha3"
+	configv1alpha4 "sigs.k8s.io/kind/pkg/apis/config/v1alpha4"
 	"sigs.k8s.io/kind/pkg/cluster"
-	"sigs.k8s.io/kind/pkg/cluster/create"
 	"sigs.k8s.io/kind/pkg/cluster/nodes"
 )
 
+const (
+	clusterName = "kube-oidc-proxy-e2e"
+)
+
 type Kind struct {
 	rootPath string
 
-	ctx        *cluster.Context
+	provider   *cluster.Provider
 	restConfig *rest.Config
 	client     *kubernetes.Clientset
 }
@@ -32,50 +35,57 @@ func New(rootPath, nodeImage string, masterNodes, workerNodes int) (*Kind, error
 
 	k := &Kind{
 		rootPath: rootPath,
-		ctx:      cluster.NewContext("kube-oidc-proxy-e2e"),
 	}
 
-	conf := new(configv1alpha3.Cluster)
-	configv1alpha3.SetDefaults_Cluster(conf)
+	conf := new(configv1alpha4.Cluster)
+	configv1alpha4.SetDefaultsCluster(conf)
 	conf.Nodes = nil
 
 	// This behviour will be changing soon in later versions of kind.
 	if workerNodes == 0 {
 		for i := 0; i < masterNodes; i++ {
 			conf.Nodes = append(conf.Nodes,
-				configv1alpha3.Node{
+				configv1alpha4.Node{
 					Image: nodeImage,
 				})
 		}
 
 	} else {
 		for i := 0; i < masterNodes; i++ {
 			conf.Nodes = append(conf.Nodes,
-				configv1alpha3.Node{
+				configv1alpha4.Node{
 					Image: nodeImage,
-					Role:  configv1alpha3.ControlPlaneRole,
+					Role:  configv1alpha4.ControlPlaneRole,
 				})
 		}
 
 		for i := 0; i < workerNodes; i++ {
 			conf.Nodes = append(conf.Nodes,
-				configv1alpha3.Node{
+				configv1alpha4.Node{
 					Image: nodeImage,
-					Role:  configv1alpha3.WorkerRole,
+					Role:  configv1alpha4.WorkerRole,
 				})
 		}
 	}
 
 	conf.Networking.ServiceSubnet = "10.0.0.0/16"
 
 	// create kind cluster
-	log.Infof("kind: creating kind cluster %q", k.ctx.Name())
-	if err := k.ctx.Create(create.WithV1Alpha3(conf)); err != nil {
-		return nil, fmt.Errorf("failed to create cluster: %s", err)
+	log.Infof("kind: creating kind cluster %q", clusterName)
+	k.provider = cluster.NewProvider()
+	if err := k.provider.Create(
+		clusterName,
+		cluster.CreateWithV1Alpha4Config(conf),
+	); err != nil {
+		return nil, err
 	}
 
 	// generate rest config to kind cluster
-	kubeconfig := k.ctx.KubeConfigPath()
+	kubeconfig, err := k.provider.KubeConfig(clusterName, false)
+	if err != nil {
+		return nil, err
+	}
+
 	restConfig, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
 	if err != nil {
 		return nil, k.errDestroy(fmt.Errorf("failed to build kind rest client: %s", err))
@@ -96,31 +106,29 @@ func New(rootPath, nodeImage string, masterNodes, workerNodes int) (*Kind, error
 		return nil, k.errDestroy(fmt.Errorf("failed to wait for DNS pods to become ready: %s", err))
 	}
 
-	log.Infof("kind: cluster ready %q", k.ctx.Name())
+	log.Infof("kind: cluster ready %q", clusterName)
 
 	return k, nil
 }
 
 func DeleteCluster(name string) error {
-	ok, err := cluster.IsKnown(name)
+	provider := cluster.NewProvider()
+
+	kubeconfig, err := provider.KubeConfig(clusterName, false)
 	if err != nil {
 		return err
 	}
 
-	if !ok {
-		return fmt.Errorf("cluster unknown: %q", name)
-	}
-
-	return cluster.NewContext(name).Delete()
+	return provider.Delete(clusterName, kubeconfig)
 }
 
 func (k *Kind) Destroy() error {
-	log.Infof("kind: destroying cluster %q", k.ctx.Name())
-	if err := k.ctx.Delete(); err != nil {
+	log.Infof("kind: destroying cluster %q", clusterName)
+	if err := DeleteCluster(clusterName); err != nil {
 		return fmt.Errorf("failed to delete kind cluster: %s", err)
 	}
 
-	log.Infof("kind: destroyed cluster %q", k.ctx.Name())
+	log.Infof("kind: destroyed cluster %q", clusterName)
 
 	return nil
 }
@@ -129,12 +137,12 @@ func (k *Kind) KubeClient() *kubernetes.Clientset {
 	return k.client
 }
 
-func (k *Kind) KubeConfigPath() string {
-	return k.ctx.KubeConfigPath()
+func (k *Kind) KubeConfigPath() (string, error) {
+	return k.provider.KubeConfig(clusterName, false)
 }
 
 func (k *Kind) Nodes() ([]nodes.Node, error) {
-	return k.ctx.ListNodes()
+	return k.provider.ListNodes(clusterName)
 }
 
 func (k *Kind) errDestroy(err error) error {