Skip to content
This repository has been archived by the owner on Aug 11, 2021. It is now read-only.

Commit

Permalink
Tidy helper functions into kubernetes and state helper packages
Browse files Browse the repository at this point in the history
  • Loading branch information
jrhouston committed May 8, 2020
1 parent c5c6fab commit ae3d64f
Show file tree
Hide file tree
Showing 358 changed files with 378 additions and 42,981 deletions.
2 changes: 1 addition & 1 deletion GNUmakefile
Original file line number Diff line number Diff line change
Expand Up @@ -18,7 +18,7 @@ test: fmtcheck
xargs -t -n4 go test $(TESTARGS) -timeout=30s -parallel=4

testacc: fmtcheck
go test $(ACCTEST) -v $(TESTARGS) -timeout 120m
go test -count=1 $(ACCTEST) -v $(TESTARGS) -timeout 120m

vet:
@echo "go vet ."
Expand Down
65 changes: 38 additions & 27 deletions acctest/configmap_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -3,45 +3,56 @@ package provider
import (
"fmt"
"testing"

statehelper "github.com/hashicorp/terraform-provider-kubernetes-alpha/acctest/helper/state"
)

// This test case tests a ConfigMap but also is a demonstration of some the assert functions
// available in the test helper
func TestKubernetesManifest_ConfigMap(t *testing.T) {
wd := helper.RequireNewWorkingDir(t)
name := randName()
namespace := randName()

tf := binhelper.RequireNewWorkingDir(t)
defer func() {
wd.RequireDestroy(t)
wd.Close()
tf.RequireDestroy(t)
tf.Close()
kubernetesHelper.AssertNamespacedResourceDoesNotExist(t, "v1", "configmaps", namespace, name)
}()

namespace := randName()
createKubernetesNamespace(t, namespace)
defer deleteKubernetesNamespace(t, namespace)
kubernetesHelper.CreateNamespace(t, namespace)
defer kubernetesHelper.DeleteNamespace(t, namespace)

name := randName()
tfconfig := testKubernetesManifestConfig_ConfigMap(namespace, name)
wd.RequireSetConfig(t, tfconfig)
wd.RequireInit(t)
wd.RequireApply(t)
tf.RequireSetConfig(t, tfconfig)
tf.RequireInit(t)
tf.RequireApply(t)

assertKubernetesNamespacedResourceExists(t, "v1", "configmaps", namespace, name)
kubernetesHelper.AssertNamespacedResourceExists(t, "v1", "configmaps", namespace, name)

state := wd.RequireState(t)
object := getObjectAttributeFromResourceState(t, state, "kubernetes_manifest.test")
assertObjectFieldEqual(t, object, "metadata.namespace", namespace)
assertObjectFieldEqual(t, object, "metadata.name", name)
assertObjectFieldEqual(t, object, "data.foo", "bar")
tfstate := statehelper.Wrap(t, tf.RequireState(t))
tfstate.AssertAttributeEqual("kubernetes_manifest.test.object.metadata.namespace", namespace)
tfstate.AssertAttributeEqual("kubernetes_manifest.test.object.metadata.name", name)
tfstate.AssertAttributeEqual("kubernetes_manifest.test.object.data.foo", "bar")

tfconfigModified := testKubernetesManifestConfig_ConfigMapModified(namespace, name)
wd.RequireSetConfig(t, tfconfigModified)
wd.RequireApply(t)

state = wd.RequireState(t)
object = getObjectAttributeFromResourceState(t, state, "kubernetes_manifest.test")
assertObjectFieldEqual(t, object, "metadata.namespace", namespace)
assertObjectFieldEqual(t, object, "metadata.name", name)
assertObjectFieldEqual(t, object, "metadata.annotations.test", "1")
assertObjectFieldEqual(t, object, "metadata.labels.test", "2")
assertObjectFieldEqual(t, object, "data.foo", "bar")
assertObjectFieldEqual(t, object, "data.fizz", "buzz")
tf.RequireSetConfig(t, tfconfigModified)
tf.RequireApply(t)

tfstate = statehelper.Wrap(t, tf.RequireState(t))
tfstate.AssertAttributeEqual("kubernetes_manifest.test.object.metadata.namespace", namespace)
tfstate.AssertAttributeEqual("kubernetes_manifest.test.object.metadata.name", name)
tfstate.AssertAttributeEqual("kubernetes_manifest.test.object.metadata.annotations.test", "1")
tfstate.AssertAttributeEqual("kubernetes_manifest.test.object.metadata.labels.test", "2")
tfstate.AssertAttributeEqual("kubernetes_manifest.test.object.data.foo", "bar")
tfstate.AssertAttributeEqual("kubernetes_manifest.test.object.data.fizz", "buzz")

tfstate.AssertAttributeLen("kubernetes_manifest.test.object.metadata.labels", 1)
tfstate.AssertAttributeLen("kubernetes_manifest.test.object.metadata.annotations", 1)

tfstate.AssertAttributeNotEmpty("kubernetes_manifest.test.object.metadata.labels.test")

tfstate.AssertAttributeDoesNotExist("kubernetes_manifest.test.spec")
}

func testKubernetesManifestConfig_ConfigMap(namespace, name string) string {
Expand Down
148 changes: 148 additions & 0 deletions acctest/helper/kubernetes/kubernetes_helper.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,148 @@
package kubernetes

import (
"context"
"testing"

"k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/client-go/dynamic"
"k8s.io/client-go/rest"
"k8s.io/client-go/tools/clientcmd"

metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

// Helper is a set of helper functions for testing against a Kubernetes cluster
type Helper struct {
client dynamic.Interface
}

// InitHelper initializes a new Kubernetes client
func InitHelper() *Helper {
rules := clientcmd.NewDefaultClientConfigLoadingRules()
overrides := &clientcmd.ConfigOverrides{}
config, err := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(rules, overrides).ClientConfig()
if err != nil {
panic(err)
}

if config == nil {
config = &rest.Config{}
}

client, err := dynamic.NewForConfig(config)
if err != nil {
panic(err)
}

return &Helper{
client: client,
}
}

// CreateNamespace creates a new namespace
func (k *Helper) CreateNamespace(t *testing.T, name string) {
t.Helper()

namespace := &unstructured.Unstructured{
Object: map[string]interface{}{
"apiVersion": "v1",
"kind": "Namespace",
"metadata": map[string]interface{}{
"name": name,
},
},
}
gvr := createGroupVersionResource("v1", "namespaces")
_, err := k.client.Resource(gvr).Create(context.TODO(), namespace, metav1.CreateOptions{})
if err != nil {
t.Errorf("Failed to create namespace %q: %v", name, err)
}
}

// DeleteNamespace deletes a namespace
func (k *Helper) DeleteNamespace(t *testing.T, name string) {
t.Helper()

gvr := createGroupVersionResource("v1", "namespaces")
err := k.client.Resource(gvr).Delete(context.TODO(), name, metav1.DeleteOptions{})
if err != nil {
t.Errorf("Failed to delete namespace %q: %v", name, err)
}
}

func createGroupVersionResource(gv, resource string) schema.GroupVersionResource {
gvr, _ := schema.ParseGroupVersion(gv)
return gvr.WithResource(resource)
}

// AssertNamespacedResourceExists will fail the current test if the resource doesn't exist in the
// specified namespace
func (k *Helper) AssertNamespacedResourceExists(t *testing.T, gv, resource, namespace, name string) {
t.Helper()

gvr := createGroupVersionResource(gv, resource)
_, err := k.client.Resource(gvr).Namespace(namespace).Get(context.TODO(), name, metav1.GetOptions{})
if errors.IsNotFound(err) {
t.Errorf("Resource %s/%s does not exist", namespace, name)
return
}

if err != nil {
t.Errorf("Error when trying to get resource %s/%s: %v", namespace, name, err)
}
}

// AssertResourceExists will fail the current test if the resource doesn't exist
func (k *Helper) AssertResourceExists(t *testing.T, gv, resource, name string) {
t.Helper()

gvr := createGroupVersionResource(gv, resource)
_, err := k.client.Resource(gvr).Get(context.TODO(), name, metav1.GetOptions{})
if errors.IsNotFound(err) {
t.Errorf("Resource %s does not exist", name)
return
}

if err != nil {
t.Errorf("Error when trying to get resource %s: %v", name, err)
}
}

// AssertNamespacedResourceDoesNotExist fails the test if the resource still exists in the namespace specified
func (k *Helper) AssertNamespacedResourceDoesNotExist(t *testing.T, gv, resource, namespace, name string) {
t.Helper()

gvr := createGroupVersionResource(gv, resource)
_, err := k.client.Resource(gvr).Namespace(namespace).Get(context.TODO(), name, metav1.GetOptions{})
if errors.IsNotFound(err) {
return
}

if err != nil {
t.Errorf("Error when trying to get resource %s/%s: %v", namespace, name, err)
return
}

t.Errorf("Resource %s/%s still exists", namespace, name)
}

// AssertResourceDoesNotExist fails the test if the resource still exists
func (k *Helper) AssertResourceDoesNotExist(t *testing.T, gv, resource, name string) {
t.Helper()

gvr := createGroupVersionResource(gv, resource)
_, err := k.client.Resource(gvr).Get(context.TODO(), name, metav1.GetOptions{})
if errors.IsNotFound(err) {
return
}

if err != nil {
t.Errorf("Error when trying to get resource %s: %v", name, err)
return
}

t.Errorf("Resource %s still exists", name)
}
Loading

0 comments on commit ae3d64f

Please sign in to comment.