github.com/verrazzano/verrazzano@v1.7.0/pkg/k8s/ready/statefulset_ready_test.go

// Copyright (c) 2021, 2023, Oracle and/or its affiliates.
// Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.

package ready

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/verrazzano/verrazzano/pkg/log/vzlog"
	appsv1 "k8s.io/api/apps/v1"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/types"
	k8scheme "k8s.io/client-go/kubernetes/scheme"
	"sigs.k8s.io/controller-runtime/pkg/client"
	"sigs.k8s.io/controller-runtime/pkg/client/fake"
)

func TestStatefulsetReady(t *testing.T) {

	selector := &metav1.LabelSelector{
		MatchLabels: map[string]string{
			"app": "foo",
		},
	}
	enoughReplicas := &appsv1.StatefulSet{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "foo",
			Namespace: "bar",
		},
		Spec: appsv1.StatefulSetSpec{
			Selector: selector,
		},
		Status: appsv1.StatefulSetStatus{
			ReadyReplicas:   1,
			UpdatedReplicas: 1,
		},
	}
	enoughReplicasMultiple := &appsv1.StatefulSet{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "foo",
			Namespace: "bar",
		},
		Spec: appsv1.StatefulSetSpec{
			Selector: selector,
		},
		Status: appsv1.StatefulSetStatus{
			ReadyReplicas:   2,
			UpdatedReplicas: 2,
		},
	}
	notEnoughReadyReplicas := &appsv1.StatefulSet{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "foo",
			Namespace: "bar",
		},
		Spec: appsv1.StatefulSetSpec{
			Selector: selector,
		},
		Status: appsv1.StatefulSetStatus{
			ReadyReplicas:   0,
			UpdatedReplicas: 1,
		},
	}
	notEnoughUpdatedReplicas := &appsv1.StatefulSet{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "foo",
			Namespace: "bar",
		},
		Spec: appsv1.StatefulSetSpec{
			Selector: selector,
		},
		Status: appsv1.StatefulSetStatus{
			ReadyReplicas:   1,
			UpdatedReplicas: 0,
		},
	}

	readyPod := &corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "foo-95d8c5d96-m6mbr",
			Namespace: "bar",
			Labels: map[string]string{
				controllerRevisionHashLabel: "foo-95d8c5d96",
				"app":                       "foo",
			},
		},
		Status: corev1.PodStatus{
			ContainerStatuses: []corev1.ContainerStatus{
				{
					Ready: true,
				},
			},
		},
	}
	notReadyContainerPod := &corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "foo-95d8c5d96-m6y76",
			Namespace: "bar",
			Labels: map[string]string{
				controllerRevisionHashLabel: "foo-95d8c5d96",
				"app":                       "foo",
			},
		},
		Status: corev1.PodStatus{
			ContainerStatuses: []corev1.ContainerStatus{
				{
					Ready: false,
				},
			},
		},
	}
	notReadyInitContainerPod := &corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "foo-95d8c5d96-m6mbr",
			Namespace: "bar",
			Labels: map[string]string{
				controllerRevisionHashLabel: "foo-95d8c5d96",
				"app":                       "foo",
			},
		},
		Status: corev1.PodStatus{
			InitContainerStatuses: []corev1.ContainerStatus{
				{
					Ready: false,
				},
			},
		},
	}
	noPodHashLabel := &corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "foo-95d8c5d96-m6mbr",
			Namespace: "bar",
			Labels: map[string]string{
				"app": "foo",
			},
		},
		Status: corev1.PodStatus{
			ContainerStatuses: []corev1.ContainerStatus{
				{
					Ready: true,
				},
			},
		},
	}

	controllerRevision := &appsv1.ControllerRevision{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "foo-95d8c5d96",
			Namespace: "bar",
		},
		Revision: 1,
	}

	namespacedName := []types.NamespacedName{
		{
			Name:      "foo",
			Namespace: "bar",
		},
	}

	var tests = []struct {
		name     string
		c        client.Client
		n        []types.NamespacedName
		ready    bool
		expected int32
	}{
		{
			"should be ready when statefulset has enough replicas and pod is ready",
			fake.NewClientBuilder().WithScheme(k8scheme.Scheme).WithObjects(enoughReplicas, readyPod, controllerRevision).Build(),
			namespacedName,
			true,
			1,
		},
		{
			"should be ready when statefulset has enough replicas and one pod of two pods is ready",
			fake.NewClientBuilder().WithScheme(k8scheme.Scheme).WithObjects(enoughReplicasMultiple, notReadyContainerPod, readyPod, controllerRevision).Build(),
			namespacedName,
			true,
			1,
		},
		{
			"should be not ready when expected pods ready not reached",
			fake.NewClientBuilder().WithScheme(k8scheme.Scheme).WithObjects(enoughReplicasMultiple, readyPod, controllerRevision).Build(),
			namespacedName,
			false,
			2,
		},
		{
			"should be not ready when statefulset has enough replicas but pod init container pods is not ready",
			fake.NewClientBuilder().WithScheme(k8scheme.Scheme).WithObjects(enoughReplicas, notReadyInitContainerPod, controllerRevision).Build(),
			namespacedName,
			false,
			1,
		},
		{
			"should be not ready when statefulset has enough replicas but pod container pods is not ready",
			fake.NewClientBuilder().WithScheme(k8scheme.Scheme).WithObjects(enoughReplicas, notReadyContainerPod, controllerRevision).Build(),
			namespacedName,
			false,
			1,
		},
		{
			"should be not ready when pod not found for statefulset",
			fake.NewClientBuilder().WithScheme(k8scheme.Scheme).WithObjects(enoughReplicas).Build(),
			namespacedName,
			false,
			1,
		},
		{
			"should be not ready when statefulset not found",
			fake.NewClientBuilder().WithScheme(k8scheme.Scheme).Build(),
			namespacedName,
			false,
			1,
		},
		{
			"should be not ready when controller-revision-hash label not found",
			fake.NewClientBuilder().WithScheme(k8scheme.Scheme).WithObjects(enoughReplicas, noPodHashLabel).Build(),
			namespacedName,
			false,
			1,
		},
		{
			"should be not ready when controllerrevision resource not found",
			fake.NewClientBuilder().WithScheme(k8scheme.Scheme).WithObjects(enoughReplicas, readyPod).Build(),
			namespacedName,
			false,
			1,
		},
		{
			"should be not ready when statefulset doesn't have enough ready replicas",
			fake.NewClientBuilder().WithScheme(k8scheme.Scheme).WithObjects(notEnoughReadyReplicas).Build(),
			namespacedName,
			false,
			1,
		},
		{
			"should be not ready when statefulset doesn't have enough updated replicas",
			fake.NewClientBuilder().WithScheme(k8scheme.Scheme).WithObjects(notEnoughUpdatedReplicas).Build(),
			namespacedName,
			false,
			1,
		},
		{
			"should be ready when no PodReadyCheck provided",
			fake.NewClientBuilder().WithScheme(k8scheme.Scheme).Build(),
			[]types.NamespacedName{},
			true,
			1,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			assert.Equal(t, tt.ready, StatefulSetsAreReady(vzlog.DefaultLogger(), tt.c, tt.n, tt.expected, ""))
		})
	}
}

func TestDoStatefulsetsExist(t *testing.T) {
	tests := []struct {
		name     string
		stsNames []types.NamespacedName
		want     bool
	}{
		{"no statefulset names provided", []types.NamespacedName{}, true},
		{"statefulset exists", []types.NamespacedName{{Name: "foo", Namespace: "bar"}}, true},
		{"all statefulsets exist", []types.NamespacedName{{Name: "foo", Namespace: "bar"}, {Name: "foo2", Namespace: "bar2"}}, true},
		{"only some statefulsets exist", []types.NamespacedName{{Name: "foo", Namespace: "bar"}, {Name: "nonexist", Namespace: "bar"}}, false},
		{"none of the statefulsets exist", []types.NamespacedName{{Name: "nofoo", Namespace: "nobar"}, {Name: "nofoo2", Namespace: "bar2"}}, false},
		{"statefulset in different namespace", []types.NamespacedName{{Name: "foo", Namespace: "bar2"}}, false},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			log := vzlog.DefaultLogger()
			fakeClient := fake.NewClientBuilder().WithScheme(k8scheme.Scheme).WithObjects(
				&appsv1.StatefulSet{
					ObjectMeta: metav1.ObjectMeta{
						Namespace: "bar",
						Name:      "foo",
					},
					Spec: appsv1.StatefulSetSpec{
						Selector: &metav1.LabelSelector{
							MatchLabels: map[string]string{
								"app": "foo",
							},
						},
					},
				},
				&appsv1.StatefulSet{
					ObjectMeta: metav1.ObjectMeta{
						Namespace: "bar2",
						Name:      "foo2",
					},
					Spec: appsv1.StatefulSetSpec{
						Selector: &metav1.LabelSelector{
							MatchLabels: map[string]string{
								"app": "foo",
							},
						},
					},
				}).Build()
			assert.Equalf(t, tt.want, DoStatefulSetsExist(log, fakeClient, tt.stsNames, 1, tt.name), "Expected %v for %s", tt.want, tt.name)
		})
	}
}