kubernetes_test.go

package mapstore

import (
	"context"
	"testing"

	"github.com/stretchr/testify/assert"
	corev1 "k8s.io/api/core/v1"
	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes/fake"
)

const (
	k8sTestName      = "foobar"
	k8sTestNamespace = "ns-foobar"
)

func fakeKubernetesClient() *kubeClient {
	return &kubeClient{fake.NewSimpleClientset(), k8sTestNamespace}
}

func TestKubernetesGetConfigMap(t *testing.T) {
	fakeClient := fakeKubernetesClient()

	// Create a ConfigMap that we can fetch.
	_, err := fakeClient.client.CoreV1().ConfigMaps(k8sTestNamespace).Create(context.Background(), &corev1.ConfigMap{
		ObjectMeta: v1.ObjectMeta{Name: k8sTestName, Namespace: k8sTestNamespace},
		BinaryData: map[string][]byte{"foo": []byte("bar")},
	}, v1.CreateOptions{})
	assert.NoError(t, err)

	// Now try fetching the ConfigMap.
	cm, err := fakeClient.getConfigMap(k8sTestName)
	assert.NoError(t, err)
	assert.NotNil(t, cm)
	assert.Equal(t, "bar", string(cm.BinaryData["foo"]))
}

func TestKubernetesGetConfigMapError(t *testing.T) {
	fakeClient := fakeKubernetesClient()

	// Now try fetching the ConfigMap.
	cm, err := fakeClient.getConfigMap(k8sTestName)
	assert.Error(t, err)
	assert.Nil(t, cm)
}

func TestKubernetesGet(t *testing.T) {
	data := map[string][]byte{"foo": []byte("bar")}
	fakeClient := fakeKubernetesClient()

	// Create a ConfigMap that we can fetch.
	_, err := fakeClient.client.CoreV1().ConfigMaps(k8sTestNamespace).Create(context.Background(), &corev1.ConfigMap{
		ObjectMeta: v1.ObjectMeta{Name: k8sTestName, Namespace: k8sTestNamespace},
		BinaryData: data,
	}, v1.CreateOptions{})
	assert.NoError(t, err)

	// Now try fetching the ConfigMap.
	result, err := fakeClient.get(k8sTestName)
	assert.NoError(t, err)
	assert.NotNil(t, result)
	assert.Equal(t, data, result)
}

func TestKubernetesGetError(t *testing.T) {
	kc := fakeKubernetesClient()

	// Now try fetching the ConfigMap.
	result, err := kc.get(k8sTestName)
	assert.Error(t, err)
	assert.Nil(t, result)
}

func TestKubernetesGetOrCreateWithNoConfigMap(t *testing.T) {
	fakeClient := fakeKubernetesClient()

	// Now try fetching the ConfigMap.
	result, err := fakeClient.getOrCreateConfigMap(k8sTestName)
	assert.NoError(t, err)
	assert.NotNil(t, result)
	assert.Empty(t, result.BinaryData)

	// Create a ConfigMap that we can fetch.
	cm, err := fakeClient.getConfigMap(k8sTestName)
	assert.NoError(t, err)
	assert.NotNil(t, cm)
	assert.Empty(t, cm.BinaryData)
}

func TestKubernetesGetOrCreateWithExistingConfigMap(t *testing.T) {
	data := map[string][]byte{"foo": []byte("bar")}
	fakeClient := fakeKubernetesClient()

	// Create a ConfigMap that we can fetch.
	_, err := fakeClient.client.CoreV1().ConfigMaps(k8sTestNamespace).Create(context.Background(), &corev1.ConfigMap{
		ObjectMeta: v1.ObjectMeta{Name: k8sTestName, Namespace: k8sTestNamespace},
		BinaryData: data,
	}, v1.CreateOptions{})
	assert.NoError(t, err)

	// Now try fetching the ConfigMap.
	result, err := fakeClient.getOrCreateConfigMap(k8sTestName)
	assert.NoError(t, err)
	assert.NotNil(t, result)
	assert.Equal(t, data, result.BinaryData)
}

func TestKubernetesSetCreate(t *testing.T) {
	data := map[string][]byte{"foo": []byte("bar")}
	fakeClient := fakeKubernetesClient()

	err := fakeClient.set(k8sTestName, data)
	assert.NoError(t, err)

	// Now try fetching the ConfigMap.
	result, err := fakeClient.get(k8sTestName)
	assert.NoError(t, err)
	assert.NotNil(t, result)
	assert.Equal(t, data, result)
}

func TestKubernetesSetUpdate(t *testing.T) {
	data := map[string][]byte{"foo": []byte("bar")}
	fakeClient := fakeKubernetesClient()

	// Create a ConfigMap that we can fetch.
	_, err := fakeClient.client.CoreV1().ConfigMaps(k8sTestNamespace).Create(context.Background(), &corev1.ConfigMap{
		ObjectMeta: v1.ObjectMeta{Name: k8sTestName, Namespace: k8sTestNamespace},
		BinaryData: data,
	}, v1.CreateOptions{})
	assert.NoError(t, err)

	newData := map[string][]byte{"foo": []byte("bar"), "num": []byte("one")}
	err = fakeClient.set(k8sTestName, newData)
	assert.NoError(t, err)

	// Now try fetching the ConfigMap.
	result, err := fakeClient.get(k8sTestName)
	assert.NoError(t, err)
	assert.NotNil(t, result)
	assert.Equal(t, newData, result)
}

func TestKubernetesDelete(t *testing.T) {
	fakeClient := fakeKubernetesClient()

	// Create a ConfigMap that we can fetch.
	_, err := fakeClient.client.CoreV1().ConfigMaps(k8sTestNamespace).Create(context.Background(), &corev1.ConfigMap{
		ObjectMeta: v1.ObjectMeta{Name: k8sTestName, Namespace: k8sTestNamespace},
		BinaryData: map[string][]byte{"foo": []byte("bar")},
	}, v1.CreateOptions{})
	assert.NoError(t, err)

	// Now try fetching the ConfigMap.
	err = fakeClient.delete(k8sTestName)
	assert.NoError(t, err)
}

func TestKubernetesDeleteError(t *testing.T) {
	fakeClient := fakeKubernetesClient()

	err := fakeClient.delete(k8sTestName)
	assert.NoError(t, err)
}