kubernetes-entrypoint/mocks/pod.go

package mocks

import (
	"context"
	"fmt"

	v1 "k8s.io/api/core/v1"
	policyv1 "k8s.io/api/policy/v1"
	policyv1beta1 "k8s.io/api/policy/v1beta1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	types "k8s.io/apimachinery/pkg/types"
	watch "k8s.io/apimachinery/pkg/watch"
	corev1applyconfigurations "k8s.io/client-go/applyconfigurations/core/v1"
	v1core "k8s.io/client-go/kubernetes/typed/core/v1"
	restclient "k8s.io/client-go/rest"
)

const MockContainerName = "TEST_CONTAINER"

type pClient struct {
}

const (
	PodNotPresent                   = "NOT_PRESENT"
	PodEnvVariableValue             = "podlist"
	FailingMatchLabel               = "INCORRECT"
	SameHostNotReadyMatchLabel      = "SAME_HOST_NOT_READY"
	SameHostReadyMatchLabel         = "SAME_HOST_READY"
	SameHostSomeReadyMatchLabel     = "SAME_HOST_SOME_READY"
	DifferentHostReadyMatchLabel    = "DIFFERENT_HOST_READY"
	DifferentHostNotReadyMatchLabel = "DIFFERENT_HOST_NOT_READY"
	NoPodsMatchLabel                = "NO_PODS"
)

func (p pClient) Create(ctx context.Context, pod *v1.Pod, opts metav1.CreateOptions) (*v1.Pod, error) {
	return nil, fmt.Errorf("not implemented")
}

func (p pClient) Update(ctx context.Context, pod *v1.Pod, opts metav1.UpdateOptions) (*v1.Pod, error) {
	return nil, fmt.Errorf("not implemented")
}

func (p pClient) UpdateStatus(ctx context.Context, pod *v1.Pod, opts metav1.UpdateOptions) (*v1.Pod, error) {
	return nil, fmt.Errorf("not implemented")
}

func (p pClient) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error {
	return fmt.Errorf("not implemented")
}

func (p pClient) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error {
	return fmt.Errorf("not implemented")
}

func (p pClient) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Pod, error) {
	if name == PodNotPresent {
		return nil, fmt.Errorf("could not get pod with the name %s", name)
	}

	return &v1.Pod{
		ObjectMeta: metav1.ObjectMeta{Name: name},
		Status: v1.PodStatus{
			ContainerStatuses: []v1.ContainerStatus{
				{
					Name:  MockContainerName,
					Ready: true,
				},
			},
			HostIP: "127.0.0.1",
		},
	}, nil
}

func (p pClient) List(ctx context.Context, opts metav1.ListOptions) (*v1.PodList, error) {
	if opts.LabelSelector == fmt.Sprintf("name=%s", FailingMatchLabel) {
		return nil, fmt.Errorf("Client received incorrect pod label names")
	}

	readyPodSameHost := NewPod(true, "127.0.0.1")
	notReadyPodSameHost := NewPod(false, "127.0.0.1")
	readyPodDifferentHost := NewPod(true, "10.0.0.1")
	notReadyPodDifferentHost := NewPod(false, "10.0.0.1")

	var pods []v1.Pod

	if opts.LabelSelector == fmt.Sprintf("name=%s", SameHostNotReadyMatchLabel) {
		pods = []v1.Pod{notReadyPodSameHost}
	}
	if opts.LabelSelector == fmt.Sprintf("name=%s", SameHostReadyMatchLabel) {
		pods = []v1.Pod{readyPodSameHost, notReadyPodDifferentHost}
	}
	if opts.LabelSelector == fmt.Sprintf("name=%s", SameHostSomeReadyMatchLabel) {
		pods = []v1.Pod{readyPodSameHost, notReadyPodSameHost}
	}
	if opts.LabelSelector == fmt.Sprintf("name=%s", DifferentHostReadyMatchLabel) {
		pods = []v1.Pod{notReadyPodSameHost, readyPodDifferentHost}
	}
	if opts.LabelSelector == fmt.Sprintf("name=%s", DifferentHostNotReadyMatchLabel) {
		pods = []v1.Pod{notReadyPodDifferentHost}
	}
	if opts.LabelSelector == fmt.Sprintf("name=%s", NoPodsMatchLabel) {
		pods = []v1.Pod{}
	}

	return &v1.PodList{
		Items: pods,
	}, nil
}

func (p pClient) Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) {
	return nil, fmt.Errorf("not implemented")
}

func (p pClient) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.Pod, err error) {
	return nil, fmt.Errorf("not implemented")
}

func (p pClient) Apply(ctx context.Context, pod *corev1applyconfigurations.PodApplyConfiguration, opts metav1.ApplyOptions) (result *v1.Pod, err error) {
	return nil, fmt.Errorf("not implemented")
}

func (p pClient) ApplyStatus(ctx context.Context, pod *corev1applyconfigurations.PodApplyConfiguration, opts metav1.ApplyOptions) (result *v1.Pod, err error) {
	return nil, fmt.Errorf("not implemented")
}

func (p pClient) UpdateEphemeralContainers(ctx context.Context, podName string, pod *v1.Pod, opts metav1.UpdateOptions) (*v1.Pod, error) {
	return nil, fmt.Errorf("not implemented")
}

func (p pClient) Bind(ctx context.Context, binding *v1.Binding, opts metav1.CreateOptions) error {
	return fmt.Errorf("not implemented")
}

func (p pClient) Evict(ctx context.Context, eviction *policyv1beta1.Eviction) error {
	return fmt.Errorf("not implemented")
}

func (p pClient) EvictV1(ctx context.Context, eviction *policyv1.Eviction) error {
	return fmt.Errorf("not implemented")
}

func (p pClient) EvictV1beta1(ctx context.Context, eviction *policyv1beta1.Eviction) error {
	return fmt.Errorf("not implemented")
}

func (p pClient) GetLogs(name string, opts *v1.PodLogOptions) *restclient.Request {
	return nil
}

func (p pClient) ProxyGet(scheme, name, port, path string, params map[string]string) restclient.ResponseWrapper {
	return nil
}

func NewPClient() v1core.PodInterface {
	return pClient{}
}

func NewPod(ready bool, hostIP string) v1.Pod {
	podReadyStatus := v1.ConditionTrue
	if !ready {
		podReadyStatus = v1.ConditionFalse
	}

	return v1.Pod{
		ObjectMeta: metav1.ObjectMeta{Name: PodEnvVariableValue},
		Status: v1.PodStatus{
			HostIP: hostIP,
			Conditions: []v1.PodCondition{
				{
					Type:   v1.PodReady,
					Status: podReadyStatus,
				},
			},
			ContainerStatuses: []v1.ContainerStatus{
				{
					Name:  MockContainerName,
					Ready: ready,
				},
			},
		},
	}
}